\n\t\t\n\n\t\t changeTheme('light')\"\n\t\t/>\n\t\t\n\t
\n\n\n\n","\n\t\n\n","\n\t\n\n\n\n\n\n","\n\t\n\t\n\n\n\n\n\n","\n\t\n\n\n\n\n\n","import { gql } from \"graphql-tag\";\nimport { EmoteSet } from \"@/structures/EmoteSet\";\n\nexport const GetEmoteSet = gql`\n\tquery GetEmoteSet($id: ObjectID!, $formats: [ImageFormat!]) {\n\t\temoteSet(id: $id) {\n\t\t\tid\n\t\t\tname\n\t\t\tflags\n\t\t\tcapacity\n\t\t\torigins {\n\t\t\t\tid\n\t\t\t\tweight\n\t\t\t}\n\t\t\temotes {\n\t\t\t\tid\n\t\t\t\tname\n\t\t\t\tactor {\n\t\t\t\t\tid\n\t\t\t\t\tdisplay_name\n\t\t\t\t\tavatar_url\n\t\t\t\t}\n\t\t\t\torigin_id\n\t\t\t\tdata {\n\t\t\t\t\tid\n\t\t\t\t\tname\n\t\t\t\t\tflags\n\t\t\t\t\tstate\n\t\t\t\t\tlifecycle\n\t\t\t\t\thost {\n\t\t\t\t\t\turl\n\t\t\t\t\t\tfiles(formats: $formats) {\n\t\t\t\t\t\t\tname\n\t\t\t\t\t\t\tformat\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\towner {\n\t\t\t\t\t\tid\n\t\t\t\t\t\tdisplay_name\n\t\t\t\t\t\tstyle {\n\t\t\t\t\t\t\tcolor\n\t\t\t\t\t\t}\n\t\t\t\t\t\troles\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\towner {\n\t\t\t\tid\n\t\t\t\tusername\n\t\t\t\tdisplay_name\n\t\t\t\tstyle {\n\t\t\t\t\tcolor\n\t\t\t\t}\n\t\t\t\tavatar_url\n\t\t\t\troles\n\t\t\t\tconnections {\n\t\t\t\t\tid\n\t\t\t\t\tdisplay_name\n\t\t\t\t\temote_capacity\n\t\t\t\t\tplatform\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n`;\n\nexport const GetEmoteSetMin = gql`\n\tquery GetEmoteSetMin($id: ObjectID!) {\n\t\temoteSet(id: $id) {\n\t\t\tid\n\t\t\tname\n\t\t\tflags\n\t\t\tcapacity\n\t\t\torigins {\n\t\t\t\tid\n\t\t\t\tweight\n\t\t\t}\n\t\t\temotes {\n\t\t\t\tid\n\t\t\t\tname\n\t\t\t\torigin_id\n\t\t\t\tdata {\n\t\t\t\t\tname\n\t\t\t\t}\n\t\t\t}\n\t\t\towner {\n\t\t\t\tid\n\t\t\t\tdisplay_name\n\t\t\t\tstyle {\n\t\t\t\t\tcolor\n\t\t\t\t}\n\t\t\t\tavatar_url\n\t\t\t\tconnections {\n\t\t\t\t\tid\n\t\t\t\t\tusername\n\t\t\t\t\tplatform\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n`;\n\nexport const GetEmoteSetForCard = gql`\n\tquery GetEmoteSetForCard($id: ObjectID!, $limit: Int) {\n\t\temoteSet(id: $id) {\n\t\t\temote_count\n\t\t\tcapacity\n\t\t\tflags\n\t\t\temotes(limit: $limit, origins: true) {\n\t\t\t\tid\n\t\t\t\tname\n\t\t\t\torigin_id\n\t\t\t\tdata {\n\t\t\t\t\tid\n\t\t\t\t\tname\n\t\t\t\t\thost {\n\t\t\t\t\t\turl\n\t\t\t\t\t\tfiles {\n\t\t\t\t\t\t\tname\n\t\t\t\t\t\t\tformat\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n`;\n\nexport interface GetEmoteSet {\n\temoteSet: EmoteSet;\n}\n","import { onBeforeUnmount } from \"vue\";\nimport { ObjectKind } from \"@/structures/Common\";\nimport type { Emote } from \"@/structures/Emote\";\nimport type { EmoteSet } from \"@/structures/EmoteSet\";\nimport type { User } from \"@/structures/User\";\nimport type { ChangeField } from \"@/worker\";\nimport { WorkerMessageData, useWorker } from \"./useWorker\";\n\nexport function useObjectSubscription() {\n\tconst subs = [] as WorkerMessageData<\"EventCommandSubscribe\">[];\n\n\tconst { postMessage, onMessage } = useWorker();\n\n\tfunction watchObject\n\t\t\t
\n\t\n\n\t\n\t\t\n\t\t\t
\n\n\t\n\t\t\n\t\n\n\t\n\t\t\n\t\t\t\t{{ tooltip.content }}\n\t\t\t
\n\t\t\n\t\t\n\t\t\t\n\t\t\t![](\"@img/waytoodank.webp\")
\n\t\t
\n\t\n\n\n\n\n\n","import { library } from \"@fortawesome/fontawesome-svg-core\";\nimport {\n\tfaChrome as fabChrome,\n\tfaDiscord as fabDiscord,\n\tfaEdge as fabEdge,\n\tfaFirefox as fabFirefox,\n\tfaGithub as fabGithub,\n\tfaOpera as fabOpera,\n\tfaCcPaypal as fabPaypal,\n\tfaTwitch as fabTwitch,\n\tfaTwitter as fabTwitter,\n\tfaYoutube as fabYoutube,\n} from \"@fortawesome/free-brands-svg-icons\";\nimport { faObjectUngroup, faCircleCheck as farCircleCheck } from \"@fortawesome/free-regular-svg-icons\";\nimport {\n\tfaArrowLeft,\n\tfaBars,\n\tfaBellConcierge,\n\tfaBookSparkles,\n\tfaBox,\n\tfaBrush,\n\tfaBullseye,\n\tfaBullseyePointer,\n\tfaCakeSlice,\n\tfaCalendarAlt,\n\tfaCheck,\n\tfaCheckCircle,\n\tfaCheckDouble,\n\tfaChevronDown,\n\tfaChevronLeft,\n\tfaChevronRight,\n\tfaChevronsDown,\n\tfaChevronsRight,\n\tfaCircle,\n\tfaClock,\n\tfaCodeBranch,\n\tfaColumns,\n\tfaCopy,\n\tfaCreditCard,\n\tfaCube,\n\tfaDownload,\n\tfaEllipsisH,\n\tfaEllipsisV,\n\tfaEnvelope,\n\tfaExclamation,\n\tfaExclamationTriangle,\n\tfaExternalLinkAlt,\n\tfaEye,\n\tfaEyeSlash,\n\tfaFaceSunglasses,\n\tfaFilter,\n\tfaFire,\n\tfaFlag,\n\tfaGavel,\n\tfaGear,\n\tfaGift,\n\tfaGlobe,\n\tfaHashtag,\n\tfaHexagonPlus,\n\tfaLanguage,\n\tfaLayerGroup,\n\tfaListCheck,\n\tfaLock,\n\tfaMegaphone,\n\tfaMerge,\n\tfaMinus,\n\tfaMoon,\n\tfaObjectGroup,\n\tfaPalette,\n\tfaPen,\n\tfaPenField,\n\tfaPersonRunningFast,\n\tfaPlus,\n\tfaRectangleWide,\n\tfaReply,\n\tfaRotateRight,\n\tfaSave,\n\tfaSeal,\n\tfaSearch,\n\tfaSlash,\n\tfaSmile,\n\tfaSquare,\n\tfaSquareQuestion,\n\tfaStar,\n\tfaSunBright,\n\tfaSync,\n\tfaTag,\n\tfaTicket,\n\tfaTimer,\n\tfaTimes,\n\tfaTrash,\n\tfaTreeChristmas,\n\tfaTrophy,\n\tfaUndo,\n\tfaUnlock,\n\tfaUser,\n\tfaUserClock,\n\tfaUserLock,\n\tfaUserMinus,\n\tfaUserPen,\n\tfaUserPlus,\n\tfaUserSlash,\n\tfaUsersCog,\n\tfaWaveformLines,\n\tfaWrench,\n} from \"@fortawesome/sharp-solid-svg-icons\";\n\nlibrary.add(\n\tfaArrowLeft,\n\tfaBars,\n\tfabChrome,\n\tfabDiscord,\n\tfabEdge,\n\tfabFirefox,\n\tfabGithub,\n\tfaBookSparkles,\n\tfabOpera,\n\tfaBox,\n\tfabPaypal,\n\tfaBrush,\n\tfabTwitch,\n\tfabTwitter,\n\tfaBullseye,\n\tfaBullseyePointer,\n\tfabYoutube,\n\tfaCakeSlice,\n\tfaCalendarAlt,\n\tfaCheck,\n\tfaCheckCircle,\n\tfaCheckDouble,\n\tfaChevronDown,\n\tfaChevronLeft,\n\tfaChevronRight,\n\tfaChevronsDown,\n\tfaChevronsRight,\n\tfaCircle,\n\tfaClock,\n\tfaCodeBranch,\n\tfaColumns,\n\tfaCopy,\n\tfaCopy,\n\tfaCreditCard,\n\tfaCube,\n\tfaDownload,\n\tfaEllipsisH,\n\tfaEllipsisV,\n\tfaEnvelope,\n\tfaExclamation,\n\tfaExclamationTriangle,\n\tfaExternalLinkAlt,\n\tfaEye,\n\tfaEyeSlash,\n\tfaFaceSunglasses,\n\tfaFilter,\n\tfaFire,\n\tfaFlag,\n\tfaGavel,\n\tfaGear,\n\tfaGift,\n\tfaGlobe,\n\tfaHashtag,\n\tfaHexagonPlus,\n\tfaLanguage,\n\tfaLayerGroup,\n\tfaListCheck,\n\tfaLock,\n\tfaMegaphone,\n\tfaMinus,\n\tfaMoon,\n\tfaObjectGroup,\n\tfaObjectUngroup,\n\tfaPalette,\n\tfaPen,\n\tfaPenField,\n\tfaPlus,\n\tfarCircleCheck,\n\tfaRectangleWide,\n\tfaReply,\n\tfaRotateRight,\n\tfaSave,\n\tfaSeal,\n\tfaSearch,\n\tfaSearch,\n\tfaSlash,\n\tfaSmile,\n\tfaSquare,\n\tfaSquareQuestion,\n\tfaStar,\n\tfaSunBright,\n\tfaSync,\n\tfaTag,\n\tfaTicket,\n\tfaTimer,\n\tfaTimes,\n\tfaTrash,\n\tfaTreeChristmas,\n\tfaTrophy,\n\tfaUndo,\n\tfaUnlock,\n\tfaUser,\n\tfaUserClock,\n\tfaUserLock,\n\tfaUserMinus,\n\tfaUserPen,\n\tfaUserPlus,\n\tfaUsersCog,\n\tfaUserSlash,\n\tfaWaveformLines,\n\tfaWrench,\n\tfaBellConcierge,\n\tfaMerge,\n\tfaPersonRunningFast,\n);\n","/**\n * Explicit keys that should always be cloned.\n */\nconst explicitKeys = [\n '__key',\n '__init',\n '__shim',\n '__original',\n '__index',\n '__prevKey',\n];\n/**\n * Generates a random string.\n * @returns string\n * @public\n */\nfunction token() {\n return Math.random().toString(36).substring(2, 15);\n}\n/**\n * Creates a new set of the specified type and uses the values from an Array or\n * an existing Set.\n * @param items -\n * @returns Set\n * @public\n */\nfunction setify(items) {\n return items instanceof Set ? items : new Set(items);\n}\n/**\n * Given 2 arrays, return them as a combined array with no duplicates.\n * @param arr1 -\n * @param arr2 -\n * @returns any[]\n * @public\n */\nfunction dedupe(arr1, arr2) {\n const original = arr1 instanceof Set ? arr1 : new Set(arr1);\n if (arr2)\n arr2.forEach((item) => original.add(item));\n return [...original];\n}\n/**\n * Checks if the given property exists on the given object.\n * @param obj -\n * @param property -\n * @public\n */\nfunction has(obj, property) {\n return Object.prototype.hasOwnProperty.call(obj, property);\n}\n/**\n * Compare two values for equality optionally at depth.\n * @param valA - Any type of input\n * @param valB - Any type of output\n * @param deep - Indicate if we should recurse into the object\n * @param explicit - Explicit keys\n * @returns boolean\n * @public\n */\nfunction eq(valA, // eslint-disable-line\nvalB, // eslint-disable-line\ndeep = true, explicit = ['__key']) {\n if (valA === valB)\n return true;\n if (typeof valB === 'object' && typeof valA === 'object') {\n if (valA instanceof Map)\n return false;\n if (valA instanceof Set)\n return false;\n if (valA instanceof Date)\n return false;\n if (valA === null || valB === null)\n return false;\n if (Object.keys(valA).length !== Object.keys(valB).length)\n return false;\n for (const k of explicit) {\n if ((k in valA || k in valB) && valA[k] !== valB[k])\n return false;\n }\n for (const key in valA) {\n if (!(key in valB))\n return false;\n if (valA[key] !== valB[key] && !deep)\n return false;\n if (deep && !eq(valA[key], valB[key], deep, explicit))\n return false;\n }\n return true;\n }\n return false;\n}\n/**\n * Determines if a value is empty or not.\n * @param value - any type of value that could be returned by an input.\n * @public\n */\nfunction empty(value // eslint-disable-line\n) {\n const type = typeof value;\n if (type === 'number')\n return false;\n if (value === undefined)\n return true;\n if (type === 'string') {\n return value === '';\n }\n if (type === 'object') {\n if (value === null)\n return true;\n for (const _i in value)\n return false;\n if (value instanceof RegExp)\n return false;\n if (value instanceof Date)\n return false;\n return true;\n }\n return false;\n}\n/**\n * Escape a string for use in regular expressions.\n * @param string - The string to escape.\n * @public\n */\nfunction escapeExp(string) {\n // $& means the whole matched string\n return string.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n/**\n * Given a string format (date) return a regex to match against.\n * @param format - The format of the string\n * @returns\n * @public\n */\nfunction regexForFormat(format) {\n const escaped = `^${escapeExp(format)}$`;\n const formats = {\n MM: '(0[1-9]|1[012])',\n M: '([1-9]|1[012])',\n DD: '([012][0-9]|3[01])',\n D: '([012]?[0-9]|3[01])',\n YYYY: '\\\\d{4}',\n YY: '\\\\d{2}',\n };\n const tokens = Object.keys(formats);\n return new RegExp(tokens.reduce((regex, format) => {\n return regex.replace(format, formats[format]);\n }, escaped));\n}\n/**\n * Given a FormKit input type\n * @param type - Any FormKit input type\n * @public\n */\nfunction nodeType(type) {\n const t = type.toLowerCase();\n if (t === 'list')\n return 'list';\n if (t === 'group')\n return 'group';\n return 'input';\n}\n/**\n * Determines if an object is an object or not.\n * @param o - any value\n * @returns\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isRecord(o) {\n return Object.prototype.toString.call(o) === '[object Object]';\n}\n/**\n * Checks if an object is a simple array or record.\n * @param o - A value to check\n * @returns\n * @public\n */\nfunction isObject(o) {\n return isRecord(o) || Array.isArray(o);\n}\n/**\n * Attempts to determine if an object is a plain object. Mostly lifted from\n * is-plain-object: https://github.com/jonschlinkert/is-plain-object\n * Copyright (c) 2014-2017, Jon Schlinkert.\n * @param o - any value\n * @returns\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nfunction isPojo(o) {\n if (isRecord(o) === false)\n return false;\n if (o.__FKNode__ || o.__POJO__ === false)\n return false;\n const ctor = o.constructor;\n if (ctor === undefined)\n return true;\n const prot = ctor.prototype;\n if (isRecord(prot) === false)\n return false;\n if (prot.hasOwnProperty('isPrototypeOf') === false) {\n return false;\n }\n return true;\n}\n/**\n * Recursively merge data from additional into original returning a new object.\n * @param original - An object to extend\n * @param additional - An object to modify the original object with.\n * @param arrays - By default replaces arrays, but can also append to them.\n * @param ignoreUndefined - when true it treats undefined values as if they dont exist\n * @public\n */\nfunction extend(original, additional, extendArrays = false, ignoreUndefined = false) {\n if (additional === null)\n return null;\n const merged = {};\n if (typeof additional === 'string')\n return additional;\n for (const key in original) {\n if (has(additional, key) &&\n (additional[key] !== undefined || !ignoreUndefined)) {\n if (extendArrays &&\n Array.isArray(original[key]) &&\n Array.isArray(additional[key])) {\n merged[key] = original[key].concat(additional[key]);\n continue;\n }\n if (additional[key] === undefined) {\n continue;\n }\n if (isPojo(original[key]) && isPojo(additional[key])) {\n merged[key] = extend(original[key], additional[key], extendArrays, ignoreUndefined);\n }\n else {\n merged[key] = additional[key];\n }\n }\n else {\n merged[key] = original[key];\n }\n }\n for (const key in additional) {\n if (!has(merged, key) && additional[key] !== undefined) {\n merged[key] = additional[key];\n }\n }\n return merged;\n}\n/**\n * Determine if the given string is fully quoted. Examples:\n * hello - false\n * \"hello\" - true\n * 'world' - true\n * \"hello\"==\"world\" - false\n * \"hello'this'\" - false\n * \"hello\"'there' - false\n * \"hello\"\"there\" - false\n * 'hello === world' - true\n * @param str - A string to check.\n * @public\n */\nfunction isQuotedString(str) {\n // quickly return false if the value is note quoted\n if (str[0] !== '\"' && str[0] !== \"'\")\n return false;\n if (str[0] !== str[str.length - 1])\n return false;\n const quoteType = str[0];\n for (let p = 1; p < str.length; p++) {\n if (str[p] === quoteType &&\n (p === 1 || str[p - 1] !== '\\\\') &&\n p !== str.length - 1) {\n return false;\n }\n }\n return true;\n}\n/**\n * Remove extra escape characters.\n * @param str - A string to remove escape characters from.\n * @public\n */\nfunction rmEscapes(str) {\n if (!str.length)\n return '';\n let clean = '';\n let lastChar = '';\n for (let p = 0; p < str.length; p++) {\n const char = str.charAt(p);\n if (char !== '\\\\' || lastChar === '\\\\') {\n clean += char;\n }\n lastChar = char;\n }\n return clean;\n}\n/**\n * Performs a recursive Object.assign like operation.\n * @param a - An object to be extended by object b\n * @param b - An object to copy values from\n * @public\n */\nfunction assignDeep(a, b) {\n for (const key in a) {\n if (has(b, key) &&\n a[key] !== b[key] &&\n !(isPojo(a[key]) && isPojo(b[key]))) {\n a[key] = b[key];\n }\n else if (isPojo(a[key]) && isPojo(b[key])) {\n assignDeep(a[key], b[key]);\n }\n }\n for (const key in b) {\n if (!has(a, key)) {\n a[key] = b[key];\n }\n }\n return a;\n}\n/**\n * Filters out values from an object that should not be considered \"props\" of\n * a core node, like \"value\" and \"name\".\n * @param attrs - An object to extract core node config from.\n * @public\n */\nfunction nodeProps(...sets) {\n return sets.reduce((valid, props) => {\n const { value, name, modelValue, config, plugins, ...validProps } = props; // eslint-disable-line\n return Object.assign(valid, validProps);\n }, {});\n}\n/**\n * Parse a string for comma-separated arguments\n * @param str - A string to parse\n * @public\n */\nfunction parseArgs(str) {\n const args = [];\n let arg = '';\n let depth = 0;\n let quote = '';\n let lastChar = '';\n for (let p = 0; p < str.length; p++) {\n const char = str.charAt(p);\n if (char === quote && lastChar !== '\\\\') {\n quote = '';\n }\n else if ((char === \"'\" || char === '\"') && !quote && lastChar !== '\\\\') {\n quote = char;\n }\n else if (char === '(' && !quote) {\n depth++;\n }\n else if (char === ')' && !quote) {\n depth--;\n }\n if (char === ',' && !quote && depth === 0) {\n args.push(arg);\n arg = '';\n }\n else if (char !== ' ' || quote) {\n arg += char;\n }\n lastChar = char;\n }\n if (arg) {\n args.push(arg);\n }\n return args;\n}\n/**\n * Return a new (shallow) object with all properties from a given object\n * that are present in the array.\n * @param obj - An object to clone\n * @param toRemove - An array of keys to remove\n * @public\n */\nfunction except(obj, toRemove) {\n const clean = {};\n const exps = toRemove.filter((n) => n instanceof RegExp);\n const keysToRemove = new Set(toRemove);\n for (const key in obj) {\n if (!keysToRemove.has(key) && !exps.some((exp) => exp.test(key))) {\n clean[key] = obj[key];\n }\n }\n return clean;\n}\n/**\n * Extracts a set of keys from a given object. Importantly, this will extract\n * values even if they are not set on the original object they will just have an\n * undefined value.\n * @param obj - An object to extract values from\n * @param include - A set of keys to extract\n * @returns\n * @public\n */\nfunction only(obj, include) {\n const clean = {};\n const exps = include.filter((n) => n instanceof RegExp);\n include.forEach((key) => {\n if (!(key instanceof RegExp)) {\n clean[key] = obj[key];\n }\n });\n Object.keys(obj).forEach((key) => {\n if (exps.some((exp) => exp.test(key))) {\n clean[key] = obj[key];\n }\n });\n return clean;\n}\n/**\n * This converts kebab-case to camelCase. It ONLY converts from kebab for\n * efficiency stake.\n * @param str - String to convert.\n * @public\n */\nfunction camel(str) {\n return str.replace(/-([a-z0-9])/gi, (_s, g) => g.toUpperCase());\n}\n/**\n * This converts camel-case to kebab case. It ONLY converts from camel to kebab.\n * @param str - Converts camel to kebab\n * @returns\n * @public\n */\nfunction kebab(str) {\n return str\n .replace(/([a-z0-9])([A-Z])/g, (_s, trail, cap) => trail + '-' + cap.toLowerCase())\n .replace(' ', '-')\n .toLowerCase();\n}\n/**\n * Very shallowly clones the given object.\n * @param obj - The object to shallow clone\n * @returns\n * @public\n */\nfunction shallowClone(obj, explicit = explicitKeys) {\n if (obj !== null && typeof obj === 'object') {\n let returnObject;\n if (Array.isArray(obj))\n returnObject = [...obj];\n else if (isPojo(obj))\n returnObject = { ...obj };\n if (returnObject) {\n applyExplicit(obj, returnObject, explicit);\n return returnObject;\n }\n }\n return obj;\n}\n/**\n * Perform a recursive clone on a given object. This only intended to be used\n * for simple objects like arrays and pojos.\n * @param obj - Object to clone\n * @public\n */\nfunction clone(obj, explicit = explicitKeys) {\n if (obj === null ||\n obj instanceof RegExp ||\n obj instanceof Date ||\n obj instanceof Map ||\n obj instanceof Set ||\n (typeof File === 'function' && obj instanceof File))\n return obj;\n let returnObject;\n if (Array.isArray(obj)) {\n returnObject = obj.map((value) => {\n if (typeof value === 'object')\n return clone(value, explicit);\n return value;\n });\n }\n else {\n returnObject = Object.keys(obj).reduce((newObj, key) => {\n newObj[key] =\n typeof obj[key] === 'object'\n ? clone(obj[key], explicit)\n : obj[key];\n return newObj;\n }, {});\n }\n for (const key of explicit) {\n if (key in obj) {\n Object.defineProperty(returnObject, key, {\n enumerable: false,\n value: obj[key],\n });\n }\n }\n return returnObject;\n}\n/**\n * Clones anything. If the item is scalar, no worries, it passes it back. if it\n * is an object, it performs a (fast/loose) clone operation.\n * @param obj - The object to clone\n * @public\n */\nfunction cloneAny(obj) {\n return typeof obj === 'object'\n ? clone(obj)\n : obj;\n}\n/**\n * Get a specific value via dot notation.\n * @param obj - An object to fetch data from\n * @param addr - An \"address\" in dot notation\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nfunction getAt(obj, addr) {\n if (!obj || typeof obj !== 'object')\n return null;\n const segments = addr.split('.');\n let o = obj;\n for (const i in segments) {\n const segment = segments[i];\n if (has(o, segment)) {\n o = o[segment];\n }\n if (+i === segments.length - 1)\n return o;\n if (!o || typeof o !== 'object')\n return null;\n }\n return null;\n}\n/**\n * Determines if the value of a prop that is either present (true) or not\n * present (undefined). For example the prop disabled should disable\n * by just existing, but what if it is set to the string \"false\" — then it\n * should not be disabled.\n * @param value - value to be checked\n * @returns\n * @public\n */\nfunction undefine(value) {\n return value !== undefined && value !== 'false' && value !== false\n ? true\n : undefined;\n}\n/**\n * Defines an object as an initial value.\n * @param obj - Object\n * @returns\n * @public\n */\n/* eslint-disable-next-line @typescript-eslint/ban-types */\nfunction init(obj) {\n return !Object.isFrozen(obj)\n ? Object.defineProperty(obj, '__init', {\n enumerable: false,\n value: true,\n })\n : obj;\n}\n/**\n * Turn any string into a URL/DOM safe string.\n * @public\n */\nfunction slugify(str) {\n return str\n .normalize('NFD')\n .replace(/[\\u0300-\\u036f]/g, '')\n .toLowerCase()\n .replace(/[^a-z0-9]/g, ' ')\n .trim()\n .replace(/\\s+/g, '-');\n}\n/**\n * Spreads an object or an array, otherwise returns the same value.\n * @param obj - Any value, but will spread objects and arrays\n * @public\n */\nfunction spread(obj, explicit = explicitKeys) {\n if (obj && typeof obj === 'object') {\n if (obj instanceof RegExp)\n return obj;\n if (obj instanceof Date)\n return obj;\n let spread;\n if (Array.isArray(obj)) {\n spread = [...obj];\n }\n else {\n spread = { ...obj };\n }\n // eslint-disable-next-line @typescript-eslint/ban-types\n return applyExplicit(obj, spread, explicit);\n }\n return obj;\n}\n/**\n * Apply non enumerable properties to an object.\n * @param obj - The object to apply non-enumerable properties to\n * @param explicit - An array of non-enumerable properties to apply\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction applyExplicit(original, obj, explicit) {\n for (const key of explicit) {\n if (key in original) {\n Object.defineProperty(obj, key, {\n enumerable: false,\n value: original[key],\n });\n }\n }\n return obj;\n}\n\nexport { assignDeep, camel, clone, cloneAny, dedupe, empty, eq, escapeExp, except, extend, getAt, has, init, isObject, isPojo, isQuotedString, isRecord, kebab, nodeProps, nodeType, only, parseArgs, regexForFormat, rmEscapes, setify, shallowClone, slugify, spread, token, undefine };\n","import { token, slugify, has, cloneAny, init, clone, camel, undefine, eq, kebab, dedupe, parseArgs, getAt, isQuotedString, rmEscapes } from '@formkit/utils';\n\n/**\n * Creates a new dispatcher that allows the addition/removal of middleware\n * functions, and the ability to dispatch a payload to all middleware.\n * @returns FormKitDispatcher\n */\nfunction createDispatcher() {\n const middleware = [];\n let currentIndex = 0;\n const use = (dispatchable) => middleware.push(dispatchable);\n const dispatch = (payload) => {\n const current = middleware[currentIndex];\n if (typeof current === 'function') {\n return current(payload, (explicitPayload) => {\n currentIndex++;\n return dispatch(explicitPayload === undefined ? payload : explicitPayload);\n });\n }\n currentIndex = 0;\n return payload;\n };\n use.dispatch = dispatch;\n use.unshift = (dispatchable) => middleware.unshift(dispatchable);\n use.remove = (dispatchable) => {\n const index = middleware.indexOf(dispatchable);\n if (index > -1)\n middleware.splice(index, 1);\n };\n return use;\n}\n\n/**\n * Creates a new event emitter, each node uses one of these to allow it to emit\n * events to local listeners and tree listeners.\n * @returns FormKitEventEmitter\n */\nfunction createEmitter() {\n const listeners = new Map();\n const receipts = new Map();\n let buffer = undefined;\n const emitter = (node, event) => {\n if (buffer) {\n buffer.set(event.name, [node, event]);\n return;\n }\n if (listeners.has(event.name)) {\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n listeners.get(event.name).forEach((wrapper) => {\n if (event.origin === node || wrapper.modifiers.includes('deep')) {\n wrapper.listener(event);\n }\n });\n }\n if (event.bubble) {\n node.bubble(event);\n }\n };\n /**\n * Add an event listener\n * @param eventName - The name of the event to listen to\n * @param listener - The callback\n * @returns string\n */\n emitter.on = (eventName, listener) => {\n const [event, ...modifiers] = eventName.split('.');\n const receipt = listener.receipt || token();\n const wrapper = {\n modifiers,\n event,\n listener,\n receipt,\n };\n /* eslint-disable @typescript-eslint/no-non-null-assertion */\n listeners.has(event)\n ? listeners.get(event).push(wrapper)\n : listeners.set(event, [wrapper]);\n receipts.has(receipt)\n ? receipts.get(receipt).push(event)\n : receipts.set(receipt, [event]);\n /* eslint-enable @typescript-eslint/no-non-null-assertion */\n return receipt;\n };\n /**\n * Remove an event listener\n * @param listenerOrReceipt - Either a receipt or the callback function.\n */\n emitter.off = (receipt) => {\n var _a;\n if (receipts.has(receipt)) {\n (_a = receipts.get(receipt)) === null || _a === void 0 ? void 0 : _a.forEach((event) => {\n const eventListeners = listeners.get(event);\n if (Array.isArray(eventListeners)) {\n listeners.set(event, eventListeners.filter((wrapper) => wrapper.receipt !== receipt));\n }\n });\n receipts.delete(receipt);\n }\n };\n /**\n * Pause emitting values. Any events emitted while paused will not be emitted\n * but rather \"stored\" — and whichever events are emitted last will be output.\n * For example:\n * pause()\n * emit('foo', 1)\n * emit('foo', 2)\n * emit('bar', 3)\n * emit('bar', 4)\n * play()\n * // would result in\n * emit('foo', 2)\n * emit('bar', 4)\n * Optionally pauses all children as well.\n * @param node - A node to pause all children on.\n */\n emitter.pause = (node) => {\n if (!buffer)\n buffer = new Map();\n if (node) {\n node.walk((child) => child._e.pause());\n }\n };\n /**\n * Release the current event buffer.\n * @param node - A node to unpause all children on.\n */\n emitter.play = (node) => {\n if (!buffer)\n return;\n const events = buffer;\n buffer = undefined;\n events.forEach(([node, event]) => emitter(node, event));\n if (node) {\n node.walk((child) => child._e.play());\n }\n };\n return emitter;\n}\n/**\n * Emit an event from this node.\n * @param node - The node that is emitting\n * @param context - The context of that node\n * @param name - The name of the event\n * @param payload - The payload to emit\n * @returns FormKitNode\n */\nfunction emit$1(node, context, name, payload, // eslint-disable-line @typescript-eslint/explicit-module-boundary-types,\nbubble = true) {\n context._e(node, {\n payload,\n name,\n bubble,\n origin: node,\n });\n return node;\n}\n/**\n * Send an event from the given node up it's ancestor tree.\n * @param node -\n * @param _context -\n * @param event -\n */\nfunction bubble(node, _context, event) {\n if (isNode(node.parent)) {\n node.parent._e(node.parent, event);\n }\n return node;\n}\n/**\n * Adds an event listener to the node for a specific event. The event name is a\n * simple string matching the name of the event to listen to. It can optionally\n * include modifiers like eventName.deep\n * @param node -\n * @param context -\n * @param name -\n * @param listener -\n * @returns FormKitNode\n */\nfunction on(_node, context, name, listener) {\n return context._e.on(name, listener);\n}\n/**\n * Removes an event listener from a node by the returned receipt from .on().\n * @param node - The node to remote the listener from\n * @param context - The context to remove\n * @param receipt - The receipt returned by .on()\n * @returns FormKitNode\n */\nfunction off(node, context, receipt) {\n context._e.off(receipt);\n return node;\n}\n\n/**\n * FormKit's global error handler.\n * @public\n */\nconst errorHandler = createDispatcher();\n/**\n * The default error handler just sets the error as the message.\n */\nerrorHandler((error, next) => {\n if (!error.message)\n error.message = String(`E${error.code}`);\n return next(error);\n});\n/**\n * FormKit's global warning handler.\n * @public\n */\nconst warningHandler = createDispatcher();\nwarningHandler((warning, next) => {\n if (!warning.message)\n warning.message = String(`W${warning.code}`);\n const result = next(warning);\n if (console && typeof console.warn === 'function')\n console.warn(result.message);\n return result;\n});\n/**\n * Globally emits a warning.\n * @param code - The integer error code.\n * @param data - Usually an object of information to include.\n * @public\n */\nfunction warn(code, data = {}) {\n warningHandler.dispatch({ code, data });\n}\n/**\n * Emits an error, generally should result in an exception.\n * @param code - The integer error code.\n * @param data - Usually an object of information to include.\n * @public\n */\nfunction error(code, data = {}) {\n throw Error(errorHandler.dispatch({ code, data }).message);\n}\n\n/**\n * Creates a new FormKitMessage object.\n * @param conf - The message configuration\n * @returns FormKitMessage\n * @public\n */\nfunction createMessage(conf, node) {\n const m = {\n blocking: false,\n key: token(),\n meta: {},\n type: 'state',\n visible: true,\n ...conf,\n };\n if (node && m.value && m.meta.localize !== false) {\n m.value = node.t(m);\n m.meta.locale = node.config.locale;\n }\n return m;\n}\n/**\n * The available traps on the node's store.\n */\nconst storeTraps = {\n apply: applyMessages,\n set: setMessage,\n remove: removeMessage,\n filter: filterMessages,\n reduce: reduceMessages,\n release: releaseBuffer,\n touch: touchMessages,\n};\n/**\n * Creates a new FormKit message store.\n * @returns FormKitStore\n */\nfunction createStore(_buffer = false) {\n const messages = {};\n let node;\n let buffer = _buffer;\n let _b = [];\n const _m = new Map();\n let _r = undefined;\n const store = new Proxy(messages, {\n get(...args) {\n const [_target, property] = args;\n if (property === 'buffer')\n return buffer;\n if (property === '_b')\n return _b;\n if (property === '_m')\n return _m;\n if (property === '_r')\n return _r;\n if (has(storeTraps, property)) {\n return storeTraps[property].bind(null, messages, store, node);\n }\n return Reflect.get(...args);\n },\n set(_t, prop, value) {\n if (prop === '_n') {\n node = value;\n if (_r === '__n')\n releaseMissed(node, store);\n return true;\n }\n else if (prop === '_b') {\n _b = value;\n return true;\n }\n else if (prop === 'buffer') {\n buffer = value;\n return true;\n }\n else if (prop === '_r') {\n _r = value;\n return true;\n }\n error(101, node);\n return false;\n },\n });\n return store;\n}\n/**\n * Adds a new value to a FormKit message bag.\n * @param store - The store itself\n * @param store - The store interface\n * @param node - The node this store belongs to\n * @param message - The message object\n * @returns FormKitStore\n */\nfunction setMessage(messageStore, store, node, message) {\n if (store.buffer) {\n store._b.push([[message]]);\n return store;\n }\n if (messageStore[message.key] !== message) {\n if (typeof message.value === 'string' && message.meta.localize !== false) {\n // Expose the value to translation\n const previous = message.value;\n message.value = node.t(message);\n if (message.value !== previous) {\n message.meta.locale = node.props.locale;\n }\n }\n const e = `message-${has(messageStore, message.key) ? 'updated' : 'added'}`;\n messageStore[message.key] = Object.freeze(node.hook.message.dispatch(message));\n node.emit(e, message);\n }\n return store;\n}\n/**\n * Run through each message in the store, and ensure it has been translated\n * to the proper language. This most frequently happens after a locale change.\n */\nfunction touchMessages(messageStore, store) {\n for (const key in messageStore) {\n const message = { ...messageStore[key] };\n store.set(message);\n }\n}\n/**\n * Remove a message from the store.\n * @param store - The store itself\n * @param store - The store interface\n * @param node - The node this store belongs to\n * @param key - The message key\n * @returns FormKitStore\n */\nfunction removeMessage(messageStore, store, node, key) {\n if (has(messageStore, key)) {\n const message = messageStore[key];\n delete messageStore[key];\n node.emit('message-removed', message);\n }\n if (store.buffer === true) {\n store._b = store._b.filter((buffered) => {\n buffered[0] = buffered[0].filter((m) => m.key !== key);\n return buffered[1] || buffered[0].length;\n });\n }\n return store;\n}\n/**\n * Iterates over all messages removing those that are no longer wanted.\n * @param messageStore - The store itself\n * @param store - The store interface\n * @param node - The node to filter for\n * @param callback - A callback accepting a message and returning a boolean\n * @param type - Pre filtered by a given message type\n */\nfunction filterMessages(messageStore, store, node, callback, type) {\n for (const key in messageStore) {\n const message = messageStore[key];\n if ((!type || message.type === type) && !callback(message)) {\n removeMessage(messageStore, store, node, key);\n }\n }\n}\n/**\n * Reduce the message store to some other generic value.\n * @param messageStore - The store itself\n * @param _store - Unused but curried — the store interface itself\n * @param _node - The node owner of this store\n * @param reducer - The callback that performs the reduction\n * @param accumulator - The initial value\n * @returns\n */\nfunction reduceMessages(messageStore, _store, _node, reducer, accumulator) {\n for (const key in messageStore) {\n const message = messageStore[key];\n accumulator = reducer(accumulator, message);\n }\n return accumulator;\n}\n/**\n *\n * @param messageStore - The store itself\n * @param _store - Unused but curried — the store interface itself\n * @param node - The node owner of this store\n * @param messages - An array of FormKitMessages to apply to this input, or an object of messages to apply to children.\n */\nfunction applyMessages(_messageStore, store, node, messages, clear) {\n if (Array.isArray(messages)) {\n if (store.buffer) {\n store._b.push([messages, clear]);\n return;\n }\n // In this case we are applying messages to this node’s store.\n const applied = new Set(messages.map((message) => {\n store.set(message);\n return message.key;\n }));\n // Remove any messages that were not part of the initial apply:\n if (typeof clear === 'string') {\n store.filter((message) => message.type !== clear || applied.has(message.key));\n }\n else if (typeof clear === 'function') {\n store.filter((message) => !clear(message) || applied.has(message.key));\n }\n }\n else {\n for (const address in messages) {\n const child = node.at(address);\n if (child) {\n child.store.apply(messages[address], clear);\n }\n else {\n missed(node, store, address, messages[address], clear);\n }\n }\n }\n}\n/**\n * Creates an array of message arrays from strings.\n * @param errors - Arrays or objects of form errors or input errors\n * @returns\n * @internal\n */\nfunction createMessages(node, ...errors) {\n const sourceKey = `${node.name}-set`;\n const make = (error) => createMessage({\n key: slugify(error),\n type: 'error',\n value: error,\n meta: { source: sourceKey, autoClear: true },\n });\n return errors\n .filter((m) => !!m)\n .map((errorSet) => {\n if (typeof errorSet === 'string')\n errorSet = [errorSet];\n if (Array.isArray(errorSet)) {\n return errorSet.map((error) => make(error));\n }\n else {\n const errors = {};\n for (const key in errorSet) {\n if (Array.isArray(errorSet[key])) {\n errors[key] = errorSet[key].map((error) => make(error));\n }\n else {\n errors[key] = [make(errorSet[key])];\n }\n }\n return errors;\n }\n });\n}\n/**\n *\n * @param store - The store to apply this missed applications.\n * @param address - The address that was missed (a node path that didn't yet exist)\n * @param messages - The messages that should have been applied.\n * @param clear - The clearing function (if any)\n */\nfunction missed(node, store, address, messages, clear) {\n var _a;\n const misses = store._m;\n if (!misses.has(address))\n misses.set(address, []);\n // The created receipt\n if (!store._r)\n store._r = releaseMissed(node, store);\n (_a = misses.get(address)) === null || _a === void 0 ? void 0 : _a.push([messages, clear]);\n}\n/**\n * Releases messages that were applied to a child via parent, but the child did\n * not exist. Once the child does exist, the created event for that child will\n * bubble to this point, and any stored applications will be applied serially.\n * @param store - The store object.\n * @returns\n */\nfunction releaseMissed(node, store) {\n return node.on('child.deep', ({ payload: child }) => {\n store._m.forEach((misses, address) => {\n if (node.at(address) === child) {\n misses.forEach(([messages, clear]) => {\n child.store.apply(messages, clear);\n });\n store._m.delete(address);\n }\n });\n // If all the stored misses were applied, remove the listener.\n if (store._m.size === 0 && store._r) {\n node.off(store._r);\n store._r = undefined;\n }\n });\n}\n/**\n * Iterates over all buffered messages and applies them in sequence.\n * @param messageStore - The store itself\n * @param store - The store interface\n * @param node - The node to filter for\n */\nfunction releaseBuffer(_messageStore, store) {\n store.buffer = false;\n store._b.forEach(([messages, clear]) => store.apply(messages, clear));\n store._b = [];\n}\n\n/**\n * Creates a new ledger for use on a single node's context.\n * @returns\n */\nfunction createLedger() {\n const ledger = {};\n let n;\n return {\n count: (...args) => createCounter(n, ledger, ...args),\n init(node) {\n n = node;\n node.on('message-added.deep', add(ledger, 1));\n node.on('message-removed.deep', add(ledger, -1));\n },\n merge: (child) => merge(n, ledger, child),\n settled(counterName) {\n return has(ledger, counterName)\n ? ledger[counterName].promise\n : Promise.resolve();\n },\n unmerge: (child) => merge(n, ledger, child, true),\n value(counterName) {\n return has(ledger, counterName) ? ledger[counterName].count : 0;\n },\n };\n}\n/**\n * Creates a new counter object in the counting ledger.\n * @param ledger - The actual ledger storage object\n * @param counterName - The name of the counter, can be arbitrary\n * @param condition - The condition function (or string) that filters messages\n * @param initialValue - The initial counter value\n * @returns\n */\nfunction createCounter(node, ledger, counterName, condition, increment = 0) {\n condition = parseCondition(condition || counterName);\n if (!has(ledger, counterName)) {\n const counter = {\n condition,\n count: 0,\n name: counterName,\n node,\n promise: Promise.resolve(),\n resolve: () => { }, // eslint-disable-line @typescript-eslint/no-empty-function\n };\n ledger[counterName] = counter;\n increment = node.store.reduce((sum, m) => sum + counter.condition(m) * 1, increment);\n node.each((child) => {\n child.ledger.count(counter.name, counter.condition);\n increment += child.ledger.value(counter.name);\n });\n }\n return count(ledger[counterName], increment).promise;\n}\n/**\n * We parse the condition to allow flexibility in how counters are specified.\n * @param condition - The condition that, if true, allows a message to change a counter's value\n * @returns\n */\nfunction parseCondition(condition) {\n if (typeof condition === 'function') {\n return condition;\n }\n return (m) => m.type === condition;\n}\n/**\n * Perform a counting action on the a given counter object of the ledger.\n * @param counter - A counter object\n * @param increment - The amount by which we are changing the count value\n * @returns\n */\nfunction count(counter, increment) {\n const initial = counter.count;\n const post = counter.count + increment;\n counter.count = post;\n if (initial === 0 && post !== 0) {\n counter.node.emit(`unsettled:${counter.name}`, counter.count, false);\n counter.promise = new Promise((r) => (counter.resolve = r));\n }\n else if (initial !== 0 && post === 0) {\n counter.node.emit(`settled:${counter.name}`, counter.count, false);\n counter.resolve();\n }\n counter.node.emit(`count:${counter.name}`, counter.count, false);\n return counter;\n}\n/**\n * Returns a function to be used as an event listener for message events.\n * @param ledger - A ledger to operate on\n * @param delta - The amount to add or subtract\n * @returns\n */\nfunction add(ledger, delta) {\n return (e) => {\n for (const name in ledger) {\n const counter = ledger[name];\n if (counter.condition(e.payload)) {\n count(counter, delta);\n }\n }\n };\n}\n/**\n * Given a child node, add the parent node's counters to the child and then\n * rectify the upstream ledger counts. Generally used when attaching a child\n * to an already counted tree.\n * @param parent - The parent that is \"receiving\" the child\n * @param ledger - The ledger object\n * @param child - The child (can be a subtree) that is being attached\n * @param remove - If the merge is removing instead of adding\n */\nfunction merge(parent, ledger, child, remove = false) {\n for (const key in ledger) {\n const condition = ledger[key].condition;\n if (!remove)\n child.ledger.count(key, condition);\n const increment = child.ledger.value(key) * (remove ? -1 : 1);\n if (!parent)\n continue;\n do {\n parent.ledger.count(key, condition, increment);\n parent = parent.parent;\n } while (parent);\n }\n}\n\n/**\n * A global registry of nodes by their alias or name (if root).\n */\nconst registry = new Map();\nconst reflected = new Map();\n/**\n * An event emitter for registered/set/unset nodes\n */\nconst emit = createEmitter();\n/**\n * Receipts of listeners.\n */\nconst receipts = [];\n/**\n * Registers a node to the registry _if_ the node is a root node, _or_ if the\n * node has an explicit node.props.alias. If these two things are not true\n * then no node is registered (idempotent).\n *\n * @param node - A node to register\n * @public\n */\nfunction register(node) {\n if (node.props.id) {\n registry.set(node.props.id, node);\n reflected.set(node, node.props.id);\n emit(node, {\n payload: node,\n name: node.props.id,\n bubble: false,\n origin: node,\n });\n }\n}\n/**\n * Deregister a node from the registry.\n * @param node - A node to remove\n * @public\n */\nfunction deregister(node) {\n if (reflected.has(node)) {\n const id = reflected.get(node); // eslint-disable-line @typescript-eslint/no-non-null-assertion\n reflected.delete(node);\n registry.delete(id);\n emit(node, {\n payload: null,\n name: id,\n bubble: false,\n origin: node,\n });\n }\n}\n/**\n * Get a node by a particular id.\n * @param node - Get a node by a given id\n * @public\n */\nfunction getNode$1(id) {\n return registry.get(id);\n}\n/**\n * Reset the entire registry.\n * @public\n */\nfunction resetRegistry() {\n registry.forEach((node) => {\n deregister(node);\n });\n receipts.forEach((receipt) => emit.off(receipt));\n}\n/**\n *\n * @param id - An id to watch\n * @param callback - A callback to notify when the node is set or removed.\n * @public\n */\nfunction watchRegistry(id, callback) {\n // register a listener\n receipts.push(emit.on(id, callback));\n}\n\n/**\n * Applies a given config change to the node.\n * @param node - The node to check for config change\n * @param prop - Checks if this property exists in the local config or props\n * @param value - The value to set\n * @internal\n */\nfunction configChange(node, prop, value) {\n // When we return false, node.walk will not continue into that child.\n let usingFallback = true;\n !(prop in node.config._t)\n ? node.emit(`config:${prop}`, value, false)\n : (usingFallback = false);\n if (!(prop in node.props)) {\n node.emit('prop', { prop, value });\n node.emit(`prop:${prop}`, value);\n }\n return usingFallback;\n}\n/**\n * Creates a new instance of a global configuration option. This object is\n * essentially just a FormKitOption object, but it can be used as the root for\n * FormKitConfig's proxy and retain event \"emitting\".\n *\n * @param options - FormKit node options to be used globally.\n * @public\n */\nfunction createConfig$1(options = {}) {\n const nodes = new Set();\n const target = {\n ...options,\n ...{\n _add: (node) => nodes.add(node),\n _rm: (node) => nodes.delete(node),\n },\n };\n const rootConfig = new Proxy(target, {\n set(t, prop, value, r) {\n if (typeof prop === 'string') {\n nodes.forEach((node) => configChange(node, prop, value));\n }\n return Reflect.set(t, prop, value, r);\n },\n });\n return rootConfig;\n}\n\n/**\n * Submits a FormKit form programmatically.\n * @param id - The id of the form\n * @public\n */\nfunction submitForm(id) {\n const formElement = document.getElementById(id);\n if (formElement instanceof HTMLFormElement) {\n const event = new Event('submit', { cancelable: true, bubbles: true });\n formElement.dispatchEvent(event);\n return;\n }\n warn(151, id);\n}\n\n/**\n * Clear all state and error messages.\n */\nfunction clearState(node) {\n const clear = (n) => {\n for (const key in n.store) {\n const message = n.store[key];\n if (message.type === 'error' ||\n (message.type === 'ui' && key === 'incomplete')) {\n n.store.remove(key);\n }\n else if (message.type === 'state') {\n n.store.set({ ...message, value: false });\n }\n }\n };\n clear(node);\n node.walk(clear);\n}\n/**\n * Resets an input to it’s \"initial\" value — if the input is a group or list it\n * resets all the children as well.\n * @param id - The id of an input to reset\n * @returns\n * @public\n */\nfunction reset(id, resetTo) {\n const node = typeof id === 'string' ? getNode$1(id) : id;\n if (node) {\n const initial = (n) => cloneAny(n.props.initial) ||\n (n.type === 'group' ? {} : n.type === 'list' ? [] : undefined);\n // pause all events in this tree.\n node._e.pause(node);\n // Set it back to basics\n node.input(cloneAny(resetTo) || initial(node), false);\n // Set children back to basics in case they were additive (had their own value for example)\n node.walk((child) => child.input(initial(child), false));\n // Finally we need to lay any values back on top (if it is a group/list) since group values\n // take precedence over child values.\n const finalInit = initial(node);\n node.input(typeof finalInit === 'object'\n ? cloneAny(resetTo) || init(finalInit)\n : finalInit, false);\n // release the events.\n node._e.play(node);\n clearState(node);\n node.emit('reset', node);\n return node;\n }\n warn(152, id);\n return;\n}\n\n/**\n * Default configuration options.\n */\nconst defaultConfig = {\n delimiter: '.',\n delay: 0,\n locale: 'en',\n rootClasses: (key) => ({ [`formkit-${kebab(key)}`]: true }),\n};\n/**\n * If a node’s name is set to useIndex, it replaces the node’s name with the\n * index of the node relative to its parent’s children.\n * @public\n */\nconst useIndex = Symbol('index');\n/**\n * When propagating values up a tree, this value indicates the child should be\n * removed.\n * @public\n */\nconst valueRemoved = Symbol('removed');\n/**\n * When propagating values up a tree, this value indicates the child should be\n * moved.\n * @public\n */\nconst valueMoved = Symbol('moved');\n/**\n * When creating a new node and having its value injected directly at a specific\n * location.\n * @public\n */\nconst valueInserted = Symbol('inserted');\n/**\n * A simple type guard to determine if the context being evaluated is a list\n * type.\n * @param arg -\n * @returns arg is FormKitListContext\n * @public\n */\nfunction isList(arg) {\n return arg.type === 'list' && Array.isArray(arg._value);\n}\n/**\n * Determine if a given object is a node\n * @public\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nfunction isNode(node) {\n return node && typeof node === 'object' && node.__FKNode__ === true;\n}\n/**\n * The setter you are trying to access is invalid.\n */\nconst invalidSetter = (node, _context, property) => {\n error(102, [node, property]);\n};\nconst traps = {\n _c: trap(getContext, invalidSetter, false),\n add: trap(addChild),\n addProps: trap(addProps),\n address: trap(getAddress, invalidSetter, false),\n at: trap(getNode),\n bubble: trap(bubble),\n clearErrors: trap(clearErrors$1),\n calm: trap(calm),\n config: trap(false),\n define: trap(define),\n disturb: trap(disturb),\n destroy: trap(destroy),\n hydrate: trap(hydrate),\n index: trap(getIndex, setIndex, false),\n input: trap(input),\n each: trap(eachChild),\n emit: trap(emit$1),\n find: trap(find),\n on: trap(on),\n off: trap(off),\n parent: trap(false, setParent),\n plugins: trap(false),\n remove: trap(removeChild),\n root: trap(getRoot, invalidSetter, false),\n reset: trap(resetValue),\n resetConfig: trap(resetConfig),\n setErrors: trap(setErrors$1),\n submit: trap(submit),\n t: trap(text),\n use: trap(use),\n name: trap(getName, false, false),\n walk: trap(walkTree),\n};\n/**\n * These are all the available \"traps\" for a given node. You can think of these\n * a little bit like methods, but they are really Proxy interceptors.\n */\nfunction createTraps() {\n return new Map(Object.entries(traps));\n}\n/**\n * Creates a getter/setter trap and curries the context/node pair\n * @param getter - The getter function\n * @param setter - The setter function\n * @param curryGetter - Indicates if the getter should be curried or not\n * @returns\n */\nfunction trap(getter, setter, curryGetter = true) {\n return {\n get: getter\n ? (node, context) => curryGetter\n ? (...args) => getter(node, context, ...args)\n : getter(node, context)\n : false,\n set: setter !== undefined ? setter : invalidSetter.bind(null),\n };\n}\n/**\n * Create all of the node's hook dispatchers.\n */\nfunction createHooks() {\n const hooks = new Map();\n return new Proxy(hooks, {\n get(_, property) {\n if (!hooks.has(property)) {\n hooks.set(property, createDispatcher());\n }\n return hooks.get(property);\n },\n });\n}\n/**\n * This is a simple integer counter of every createName() where the name needs\n * to be generated.\n */\nlet nameCount = 0;\n/**\n * This is a simple integer counter of every default id created.\n */\nlet idCount = 0;\n/**\n * Reports the global number of node registrations, useful for deterministic\n * node naming.\n * @public\n */\nfunction resetCount() {\n nameCount = 0;\n idCount = 0;\n}\n/**\n * Create a name based dictionary of all children in an array.\n * @param children -\n * @public\n */\nfunction names(children) {\n return children.reduce((named, child) => Object.assign(named, { [child.name]: child }), {});\n}\n/**\n * This node is responsible for deterministically generating an id for this\n * node. This cannot just be a random id, it _must_ be deterministic to ensure\n * re-hydration of the form (like post-SSR) produces the same names/ids.\n *\n * @param options -\n * @returns string\n */\nfunction createName(options) {\n var _a, _b;\n if (((_a = options.parent) === null || _a === void 0 ? void 0 : _a.type) === 'list')\n return useIndex;\n return options.name || `${((_b = options.props) === null || _b === void 0 ? void 0 : _b.type) || 'input'}_${++nameCount}`;\n}\n/**\n * Creates the initial value for a node based on the options passed in and the\n * type of the input.\n * @param options -\n * @param type -\n * @returns\n * @internal\n */\nfunction createValue(options) {\n if (options.type === 'group') {\n return init(options.value &&\n typeof options.value === 'object' &&\n !Array.isArray(options.value)\n ? options.value\n : {});\n }\n else if (options.type === 'list') {\n return init(Array.isArray(options.value) ? options.value : []);\n }\n return options.value;\n}\n/**\n * Sets the internal value of the node.\n * @param node -\n * @param context -\n * @param value -\n * @returns T\n */\nfunction input(node, context, value, async = true) {\n context._value = validateInput(node, node.hook.input.dispatch(value));\n node.emit('input', context._value);\n if (context.isSettled)\n node.disturb();\n if (async) {\n if (context._tmo)\n clearTimeout(context._tmo);\n context._tmo = setTimeout(commit, node.props.delay, node, context);\n }\n else {\n commit(node, context);\n }\n return context.settled;\n}\n/**\n * Validate that the current input is allowed.\n * @param type - The type of node (input, list, group)\n * @param value - The value that is being set\n */\nfunction validateInput(node, value) {\n switch (node.type) {\n // Inputs are allowed to have any type\n case 'input':\n break;\n case 'group':\n if (!value || typeof value !== 'object')\n error(107, [node, value]);\n break;\n case 'list':\n if (!Array.isArray(value))\n error(108, [node, value]);\n break;\n }\n return value;\n}\n/**\n * Commits the working value to the node graph as the value of this node.\n * @param node -\n * @param context -\n * @param calm -\n * @param hydrate -\n */\nfunction commit(node, context, calm = true, hydrate = true) {\n context._value = context.value = node.hook.commit.dispatch(context._value);\n if (node.type !== 'input' && hydrate)\n node.hydrate();\n node.emit('commit', context.value);\n if (calm)\n node.calm();\n}\n/**\n * Perform a modification to a single element of a parent aggregate value. This\n * is only performed on the pre-committed value (_value), although typically\n * the value and _value are both linked in memory.\n * @param context -\n * @param name -\n * @param value -\n */\nfunction partial(context, { name, value, from }) {\n if (Object.isFrozen(context._value))\n return;\n if (isList(context)) {\n const insert = value === valueRemoved\n ? []\n : value === valueMoved && typeof from === 'number'\n ? context._value.splice(from, 1)\n : [value];\n context._value.splice(name, value === valueMoved || from === valueInserted ? 0 : 1, ...insert);\n return;\n }\n // In this case we know for sure we're dealing with a group, TS doesn't\n // know that however, so we use some unpleasant casting here\n if (value !== valueRemoved) {\n context._value[name] = value;\n }\n else {\n delete context._value[name];\n }\n}\n/**\n * Pass values down to children by calling hydrate on them.\n * @param parent -\n * @param child -\n */\nfunction hydrate(node, context) {\n const _value = context._value;\n context.children.forEach((child) => {\n if (typeof _value !== 'object')\n return;\n // if (has(context._value as FormKitGroupValue, child.name)) {\n if (child.name in _value) {\n // In this case, the parent has a value to give to the child, so we\n // perform a down-tree synchronous input which will cascade values down\n // and then ultimately back up.\n const childValue = child.type !== 'input' ||\n (_value[child.name] && typeof _value[child.name] === 'object')\n ? init(_value[child.name])\n : _value[child.name];\n child.input(childValue, false);\n }\n else {\n if (node.type !== 'list' || typeof child.name === 'number') {\n // In this case, the parent’s values have no knowledge of the child\n // value — this typically occurs on the commit at the end of addChild()\n // we need to create a value reservation for this node’s name. This is\n // especially important when dealing with lists where index matters.\n partial(context, { name: child.name, value: child.value });\n }\n if (!_value.__init) {\n // In this case, someone has explicitly set the value to an empty object\n // with node.input({}) so we do not define the __init property:\n if (child.type === 'group')\n child.input({}, false);\n else if (child.type === 'list')\n child.input([], false);\n else\n child.input(undefined, false);\n }\n }\n });\n return node;\n}\n/**\n * Disturbs the state of a node from settled to unsettled — creating appropriate\n * promises and resolutions.\n * @param node -\n * @param context -\n */\nfunction disturb(node, context) {\n var _a;\n if (context._d <= 0) {\n context.isSettled = false;\n node.emit('settled', false, false);\n context.settled = new Promise((resolve) => {\n context._resolve = resolve;\n });\n if (node.parent)\n (_a = node.parent) === null || _a === void 0 ? void 0 : _a.disturb();\n }\n context._d++;\n return node;\n}\n/**\n * Calms the given node's disturbed state by one.\n * @param node -\n * @param context -\n */\nfunction calm(node, context, value) {\n var _a;\n if (value !== undefined && node.type !== 'input') {\n partial(context, value);\n // Commit the value up, but do not hydrate back down\n return commit(node, context, true, false);\n }\n if (context._d > 0)\n context._d--;\n if (context._d === 0) {\n context.isSettled = true;\n node.emit('settled', true, false);\n if (node.parent)\n (_a = node.parent) === null || _a === void 0 ? void 0 : _a.calm({ name: node.name, value: context.value });\n if (context._resolve)\n context._resolve(context.value);\n }\n}\n/**\n * This node is being removed and needs to be cleaned up.\n * @param node - The node to shut down\n * @param context - The context to clean up\n */\nfunction destroy(node, context) {\n node.emit('destroying', node);\n // flush all messages out\n node.store.filter(() => false);\n if (node.parent) {\n node.parent.remove(node);\n }\n deregister(node);\n context._value = context.value = undefined;\n node.emit('destroyed', node);\n}\n/**\n * Defines the current input type concretely.\n * @param definition - The definition of the current input type.\n */\nfunction define(node, context, definition) {\n // Assign the type\n context.type = definition.type;\n // Assign the definition\n context.props.definition = clone(definition);\n // Ensure the type is seeded with the `__init` value.\n context.value = context._value = createValue({\n type: node.type,\n value: context.value,\n });\n /**\n * If the user has a typename defined, use it here.\n */\n if (definition.forceTypeProp) {\n if (node.props.type)\n node.props.originalType = node.props.type;\n context.props.type = definition.forceTypeProp;\n }\n /**\n * If the input is part of a family of inputs, add that prop.\n */\n if (definition.family) {\n context.props.family = definition.family;\n }\n // Apply any input features before resetting the props.\n if (definition.features) {\n definition.features.forEach((feature) => feature(node));\n }\n // Its possible that input-defined \"props\" have ended up in the context attrs\n // these should be moved back out of the attrs object.\n if (definition.props) {\n node.addProps(definition.props);\n }\n node.emit('defined', definition);\n}\n/**\n * Adds props to a given node by stripping them out of the node.props.attrs and\n * then adding them to the nodes.\n *\n * @param node - The node to add props to\n * @param context - The internal context object\n * @param props - An array of prop strings (in camelCase!)\n */\nfunction addProps(node, context, props) {\n var _a;\n if (node.props.attrs) {\n const attrs = { ...node.props.attrs };\n // Temporarily disable prop emits\n node.props._emit = false;\n for (const attr in attrs) {\n const camelName = camel(attr);\n if (props.includes(camelName)) {\n node.props[camelName] = attrs[attr];\n delete attrs[attr];\n }\n }\n const initial = cloneAny(context._value);\n node.props.initial =\n node.type !== 'input' ? init(initial) : initial;\n // Re-enable prop emits\n node.props._emit = true;\n node.props.attrs = attrs;\n if (node.props.definition) {\n node.props.definition.props = [\n ...(((_a = node.props.definition) === null || _a === void 0 ? void 0 : _a.props) || []),\n ...props,\n ];\n }\n }\n node.emit('added-props', props);\n return node;\n}\n/**\n * (node.add) Adds a child to the node.\n * @param context -\n * @param node -\n * @param child -\n */\nfunction addChild(parent, parentContext, child, listIndex) {\n if (parent.type === 'input')\n error(100, parent);\n if (child.parent && child.parent !== parent) {\n child.parent.remove(child);\n }\n // Synchronously set the initial value on the parent\n if (!parentContext.children.includes(child)) {\n if (listIndex !== undefined && parent.type === 'list') {\n // Inject the child:\n parentContext.children.splice(listIndex, 0, child);\n if (Array.isArray(parent.value) &&\n parent.value.length < parentContext.children.length) {\n // When adding an node or value to a list it is absolutely critical to\n // know if, at the moment of injection, the parent’s value or the node\n // children are the source of truth. For example, if a user pushes or\n // splices a new value onto the lists’s array then we want to use that\n // value as the value of the new node, but if a user adds a node to the\n // list then we want the node’s value. In this specific case, we\n // assume (due to length) that a new node was injected into the list, so\n // we want that new node’s value injected into the parent list value.\n parent.disturb().calm({\n name: listIndex,\n value: child.value,\n from: valueInserted,\n });\n }\n }\n else {\n parentContext.children.push(child);\n }\n if (!child.isSettled)\n parent.disturb();\n }\n if (child.parent !== parent) {\n child.parent = parent;\n // In this edge case middleware changed the parent assignment so we need to\n // re-add the child\n if (child.parent !== parent) {\n parent.remove(child);\n child.parent.add(child);\n return parent;\n }\n }\n else {\n // When a parent is properly assigned, we inject the parent's plugins on the\n // child.\n child.use(parent.plugins);\n }\n // Finally we call commit here, which sub-calls hydrate(), hydrate() will\n // resolve any conflict between the parent and child values, and also ensure\n // proper \"placeholders\" are made on the parent.\n commit(parent, parentContext, false);\n parent.ledger.merge(child);\n parent.emit('child', child);\n return parent;\n}\n/**\n * The setter for node.parent = FormKitNode\n * @param _context -\n * @param node -\n * @param _property -\n * @param parent -\n * @returns boolean\n */\nfunction setParent(child, context, _property, parent) {\n if (isNode(parent)) {\n if (child.parent && child.parent !== parent) {\n child.parent.remove(child);\n }\n context.parent = parent;\n child.resetConfig();\n !parent.children.includes(child)\n ? parent.add(child)\n : child.use(parent.plugins);\n return true;\n }\n if (parent === null) {\n context.parent = null;\n return true;\n }\n return false;\n}\n/**\n * (node.remove) Removes a child from the node.\n * @param context -\n * @param node -\n * @param child -\n */\nfunction removeChild(node, context, child) {\n const childIndex = context.children.indexOf(child);\n if (childIndex !== -1) {\n if (child.isSettled)\n node.disturb();\n context.children.splice(childIndex, 1);\n // If an ancestor uses the preserve prop, then we are expected to not remove\n // our values on this node either, see #53\n let preserve = undefine(child.props.preserve);\n let parent = child.parent;\n while (preserve === undefined && parent) {\n preserve = undefine(parent.props.preserve);\n parent = parent.parent;\n }\n if (!preserve) {\n node.calm({\n name: node.type === 'list' ? childIndex : child.name,\n value: valueRemoved,\n });\n }\n else {\n node.calm();\n }\n child.parent = null;\n // Remove the child from the config. Is this weird? Yes. Is it ok? Yes.\n child.config._rmn = child;\n }\n node.ledger.unmerge(child);\n return node;\n}\n/**\n * Iterate over each immediate child and perform a callback.\n * @param context -\n * @param _node -\n * @param callback -\n */\nfunction eachChild(_node, context, callback) {\n context.children.forEach((child) => callback(child));\n}\n/**\n * Walk all nodes below this one and execute a callback.\n * @param _node -\n * @param context -\n * @param callback -\n */\nfunction walkTree(_node, context, callback, stopIfFalse = false) {\n context.children.forEach((child) => {\n if (callback(child) !== false || !stopIfFalse) {\n child.walk(callback, stopIfFalse);\n }\n });\n}\n/**\n * Set the configuration options of the node and it's subtree.\n * @param node -\n * @param context -\n * @param _property -\n * @param config -\n */\nfunction resetConfig(node, context) {\n const parent = node.parent || undefined;\n context.config = createConfig(node.config._t, parent);\n node.walk((n) => n.resetConfig());\n}\n/**\n * Adds a plugin to the node, it’s children, and executes it.\n * @param context -\n * @param node -\n * @param plugin -\n * @public\n */\nfunction use(node, context, plugin, run = true, library = true) {\n if (Array.isArray(plugin) || plugin instanceof Set) {\n plugin.forEach((p) => use(node, context, p));\n return node;\n }\n if (!context.plugins.has(plugin)) {\n if (library && typeof plugin.library === 'function')\n plugin.library(node);\n // When plugins return false, they are never added as to the plugins Set\n // meaning they only ever have access to the single node they were added on.\n if (run && plugin(node) !== false) {\n context.plugins.add(plugin);\n node.children.forEach((child) => child.use(plugin));\n }\n }\n return node;\n}\n/**\n * Moves a node in the parent’s children to the given index.\n * @param node -\n * @param _context -\n * @param _property -\n * @param setIndex -\n */\nfunction setIndex(node, _context, _property, setIndex) {\n if (isNode(node.parent)) {\n const children = node.parent.children;\n const index = setIndex >= children.length\n ? children.length - 1\n : setIndex < 0\n ? 0\n : setIndex;\n const oldIndex = children.indexOf(node);\n if (oldIndex === -1)\n return false;\n children.splice(oldIndex, 1);\n children.splice(index, 0, node);\n node.parent.children = children;\n if (node.parent.type === 'list')\n node.parent\n .disturb()\n .calm({ name: index, value: valueMoved, from: oldIndex });\n return true;\n }\n return false;\n}\n/**\n * Retrieves the index of a node from the parent’s children.\n * @param node -\n */\nfunction getIndex(node) {\n if (node.parent) {\n const index = [...node.parent.children].indexOf(node);\n // If the index is currently -1 then the node isnt finished booting, so it\n // must be the next node.\n return index === -1 ? node.parent.children.length : index;\n }\n return -1;\n}\n/**\n * Retrieves the context object of a given node. This is intended to be a\n * private trap and should absolutely not be used in plugins or user-land code.\n * @param _node -\n * @param context -\n */\nfunction getContext(_node, context) {\n return context;\n}\n/**\n * Get the name of the current node, allowing for slight mutations.\n * @param node -\n * @param context -\n */\nfunction getName(node, context) {\n var _a;\n if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === 'list')\n return node.index;\n return context.name !== useIndex ? context.name : node.index;\n}\n/**\n * Returns the address of the current node.\n * @param node -\n * @param context -\n */\nfunction getAddress(node, context) {\n return context.parent\n ? context.parent.address.concat([node.name])\n : [node.name];\n}\n/**\n * Fetches a node from the tree by its address.\n * @param context -\n * @param node -\n * @param location -\n * @returns FormKitNode\n */\nfunction getNode(node, _context, locator) {\n const address = typeof locator === 'string' ? locator.split(node.config.delimiter) : locator;\n if (!address.length)\n return undefined;\n const first = address[0];\n let pointer = node.parent;\n if (!pointer) {\n // This address names the root node, remove it to get child name:\n if (String(address[0]) === String(node.name))\n address.shift();\n // All root nodes start at themselves ultimately:\n pointer = node;\n }\n // Any addresses starting with $parent should discard it\n if (first === '$parent')\n address.shift();\n while (pointer && address.length) {\n const name = address.shift();\n switch (name) {\n case '$root':\n pointer = node.root;\n break;\n case '$parent':\n pointer = pointer.parent;\n break;\n case '$self':\n pointer = node;\n break;\n default:\n pointer =\n pointer.children.find((c) => String(c.name) === String(name)) ||\n select(pointer, name);\n }\n }\n return pointer || undefined;\n}\n/**\n * Perform selections on a subtree using the address \"selector\" methods.\n * @param node -\n * @param selector -\n * @returns FormKitNode | undefined\n */\nfunction select(node, selector) {\n const matches = String(selector).match(/^(find)\\((.*)\\)$/);\n if (matches) {\n const [, action, argStr] = matches;\n const args = argStr.split(',').map((arg) => arg.trim());\n switch (action) {\n case 'find':\n return node.find(args[0], args[1]);\n default:\n return undefined;\n }\n }\n return undefined;\n}\n/**\n * Perform a breadth first search and return the first instance of a node that\n * is found in the subtree or undefined.\n * @param node - The node to start the search on/under\n * @param _context - The context object\n * @param searchTerm - The term we are searching for\n * @param searcher - Either a key to search on, or a function\n * @returns\n */\nfunction find(node, _context, searchTerm, searcher) {\n return bfs(node, searchTerm, searcher);\n}\n/**\n * Perform a breadth-first-search on a node subtree and locate the first\n * instance of a match.\n * @param node -\n * @param name -\n * @returns FormKitNode\n * @public\n */\nfunction bfs(tree, searchValue, searchGoal = 'name') {\n const search = typeof searchGoal === 'string'\n ? (n) => n[searchGoal] == searchValue // non-strict comparison is intentional\n : searchGoal;\n const stack = [tree];\n while (stack.length) {\n const node = stack.shift(); // eslint-disable-line @typescript-eslint/no-non-null-assertion\n if (search(node, searchValue))\n return node;\n stack.push(...node.children);\n }\n return undefined;\n}\n/**\n * Get the root node of the tree.\n */\nfunction getRoot(n) {\n let node = n;\n while (node.parent) {\n node = node.parent;\n }\n return node;\n}\n/**\n * Creates a new configuration option.\n * @param parent -\n * @param configOptions -\n * @returns FormKitConfig\n */\nfunction createConfig(target = {}, parent) {\n let node = undefined;\n return new Proxy(target, {\n get(...args) {\n const prop = args[1];\n if (prop === '_t')\n return target;\n const localValue = Reflect.get(...args);\n // Check our local values first\n if (localValue !== undefined)\n return localValue;\n // Then check our parent values next\n if (parent) {\n const parentVal = parent.config[prop];\n if (parentVal !== undefined)\n return parentVal;\n }\n if (target.rootConfig && typeof prop === 'string') {\n const rootValue = target.rootConfig[prop];\n if (rootValue !== undefined)\n return rootValue;\n }\n // The default delay value should be 20\n if (prop === 'delay' && (node === null || node === void 0 ? void 0 : node.type) === 'input')\n return 20;\n // Finally check the default values\n return defaultConfig[prop];\n },\n set(...args) {\n const prop = args[1];\n const value = args[2];\n if (prop === '_n') {\n node = value;\n if (target.rootConfig)\n target.rootConfig._add(node);\n return true;\n }\n if (prop === '_rmn') {\n if (target.rootConfig)\n target.rootConfig._rm(node);\n node = undefined;\n return true;\n }\n if (!eq(target[prop], value, false)) {\n const didSet = Reflect.set(...args);\n if (node) {\n node.emit(`config:${prop}`, value, false);\n configChange(node, prop, value);\n // Walk the node tree and notify of config/prop changes where relevant\n node.walk((n) => configChange(n, prop, value), true);\n }\n return didSet;\n }\n return true;\n },\n });\n}\n/**\n * Given a string of text, expose it for modification, translation, or full\n * replacement.\n * @param key - A message key, or generic string of text\n * @returns\n */\nfunction text(node, _context, key, type = 'ui') {\n const fragment = typeof key === 'string' ? { key, value: key, type } : key;\n const value = node.hook.text.dispatch(fragment);\n node.emit('text', value, false);\n return value.value;\n}\n/**\n * Submits the nearest ancestor that is a FormKit \"form\". It determines which\n * node is a form by locating an ancestor where node.props.isForm = true.\n * @param node - The node to initiate the submit\n */\nfunction submit(node) {\n const name = node.name;\n do {\n if (node.props.isForm === true)\n break;\n if (!node.parent)\n error(106, name);\n node = node.parent;\n } while (node);\n if (node.props.id) {\n submitForm(node.props.id);\n }\n}\n/**\n * Reset to the original value.\n * @param node - The node to reset\n * @param _context - The context\n * @param value - The value to reset to\n */\nfunction resetValue(node, _context, value) {\n return reset(node, value);\n}\n/**\n * Sets errors on the node and optionally its children.\n * @param node - The node to set errors on\n * @param _context - Not used\n * @param localErrors - An array of errors to set on this node\n * @param childErrors - An object of name to errors to set on children.\n */\nfunction setErrors$1(node, _context, localErrors, childErrors) {\n const sourceKey = `${node.name}-set`;\n const errors = node.hook.setErrors.dispatch({ localErrors, childErrors });\n createMessages(node, errors.localErrors, errors.childErrors).forEach((errors) => {\n node.store.apply(errors, (message) => message.meta.source === sourceKey);\n });\n return node;\n}\n/**\n * Clears errors on the node and optionally its children.\n * @param node - The node to set errors on\n * @param _context - Not used\n * @param localErrors - An array of errors to set on this node\n * @param childErrors - An object of name to errors to set on children.\n */\nfunction clearErrors$1(node, context, clearChildErrors = true, sourceKey) {\n setErrors$1(node, context, []);\n if (clearChildErrors) {\n sourceKey = sourceKey || `${node.name}-set`;\n node.walk((child) => {\n child.store.filter((message) => {\n return !(message.type === 'error' &&\n message.meta &&\n message.meta.source === sourceKey);\n });\n });\n }\n return node;\n}\n/**\n * Middleware to assign default prop values as issued by core.\n * @param node - The node being registered\n * @param next - Calls the next middleware.\n * @returns\n */\nfunction defaultProps(node) {\n if (!has(node.props, 'id'))\n node.props.id = `input_${idCount++}`;\n return node;\n}\n/**\n * @param options -\n * @param config -\n */\nfunction createProps(initial) {\n const props = {\n initial: typeof initial === 'object' ? cloneAny(initial) : initial,\n };\n let node;\n let isEmitting = true;\n return new Proxy(props, {\n get(...args) {\n const [_t, prop] = args;\n if (has(props, prop))\n return Reflect.get(...args);\n if (node && typeof prop === 'string' && node.config[prop] !== undefined)\n return node.config[prop];\n return undefined;\n },\n set(target, property, originalValue, receiver) {\n if (property === '_n') {\n node = originalValue;\n return true;\n }\n if (property === '_emit') {\n isEmitting = originalValue;\n return true;\n }\n const { prop, value } = node.hook.prop.dispatch({\n prop: property,\n value: originalValue,\n });\n // Typescript compiler cannot handle a symbol index, even though js can:\n if (!eq(props[prop], value, false) ||\n typeof value === 'object') {\n const didSet = Reflect.set(target, prop, value, receiver);\n if (isEmitting) {\n node.emit('prop', { prop, value });\n if (typeof prop === 'string')\n node.emit(`prop:${prop}`, value);\n }\n return didSet;\n }\n return true;\n },\n });\n}\n/**\n * A cheap function that iterates over all plugins and stops once node.define\n * is called.\n * @param node - A formkit node\n * @param plugins - An array of plugins\n * @returns\n */\nfunction findDefinition(node, plugins) {\n // If the definition is already there, force call to define.\n if (node.props.definition)\n return node.define(node.props.definition);\n for (const plugin of plugins) {\n if (node.props.definition)\n return;\n if (typeof plugin.library === 'function') {\n plugin.library(node);\n }\n }\n}\n/**\n * Create a new context object for our a FormKit node, given default information\n * @param options - An options object to override the defaults.\n * @returns FormKitContext\n */\nfunction createContext(options) {\n const value = createValue(options);\n const config = createConfig(options.config || {}, options.parent);\n return {\n _d: 0,\n _e: createEmitter(),\n _resolve: false,\n _tmo: false,\n _value: value,\n children: dedupe(options.children || []),\n config,\n hook: createHooks(),\n isCreated: false,\n isSettled: true,\n ledger: createLedger(),\n name: createName(options),\n parent: options.parent || null,\n plugins: new Set(),\n props: createProps(value),\n settled: Promise.resolve(value),\n store: createStore(true),\n traps: createTraps(),\n type: options.type || 'input',\n value,\n };\n}\n/**\n * Initialize a node object's internal properties.\n * @param node - The node to initialize\n * @returns FormKitNode\n */\nfunction nodeInit(node, options) {\n var _a;\n // Set the internal node on the props, config, ledger and store\n node.ledger.init((node.store._n = node.props._n = node.config._n = node));\n // Apply given in options to the node.\n node.props._emit = false;\n if (options.props)\n Object.assign(node.props, options.props);\n node.props._emit = true;\n // Attempt to find a definition from the pre-existing plugins.\n findDefinition(node, new Set([\n ...(options.plugins || []),\n ...(node.parent ? node.parent.plugins : []),\n ]));\n // Then we apply each plugin's root code, we do this with an explicit loop\n // for that ity-bitty performance bump.\n if (options.plugins) {\n for (const plugin of options.plugins) {\n use(node, node._c, plugin, true, false);\n }\n }\n // Initialize the default props\n defaultProps(node);\n // Apply the parent to each child.\n node.each((child) => node.add(child));\n // If the node has a parent, ensure it's properly nested bi-directionally.\n if (node.parent)\n node.parent.add(node, options.index);\n // Inputs are leafs, and cannot have children\n if (node.type === 'input' && node.children.length)\n error(100, node);\n // Apply the input hook to the initial value.\n input(node, node._c, node._value, false);\n // Release the store buffer\n node.store.release();\n // Register the node globally if someone explicitly gave it an id\n if ((_a = options.props) === null || _a === void 0 ? void 0 : _a.id)\n register(node);\n // Our node is finally ready, emit it to the world\n node.emit('created', node);\n node.isCreated = true;\n return node;\n}\n/**\n * Creates a new instance of a FormKit Node. Nodes are the atomic unit of\n * a FormKit graph.\n *\n * @param options - An object of options to define the node.\n * @returns FormKitNode\n * @public\n */\nfunction createNode(options) {\n const ops = options || {};\n const context = createContext(ops);\n // Note: The typing for the proxy object cannot be fully modeled, thus we are\n // force-typing to a FormKitNode. See:\n // https://github.com/microsoft/TypeScript/issues/28067\n const node = new Proxy(context, {\n get(...args) {\n const [, property] = args;\n if (property === '__FKNode__')\n return true;\n const trap = context.traps.get(property);\n if (trap && trap.get)\n return trap.get(node, context);\n return Reflect.get(...args);\n },\n set(...args) {\n const [, property, value] = args;\n const trap = context.traps.get(property);\n if (trap && trap.set)\n return trap.set(node, context, property, value);\n return Reflect.set(...args);\n },\n });\n return nodeInit(node, ops);\n}\n\n/**\n * Type narrow that a node is a DOM node.\n * @param node - A schema node to check\n * @returns\n * @public\n */\nfunction isDOM(node) {\n return typeof node !== 'string' && has(node, '$el');\n}\n/**\n * Type narrow that a node is a DOM node.\n * @param node - A schema node to check\n * @returns\n * @public\n */\nfunction isComponent(node) {\n return typeof node !== 'string' && has(node, '$cmp');\n}\n/**\n * Root declaration.\n * @param node - An object to check\n * @returns\n * @public\n */\nfunction isConditional(node) {\n if (!node || typeof node === 'string')\n return false;\n return has(node, 'if') && has(node, 'then');\n}\n/**\n * Determines if the node is syntactic sugar or not.\n * @param node - Node\n * @returns\n * @public\n */\nfunction isSugar(node) {\n return typeof node !== 'string' && '$formkit' in node;\n}\n/**\n * Converts syntactic sugar nodes to standard nodes.\n * @param node - A node to covert\n * @returns\n * @public\n */\nfunction sugar(node) {\n if (typeof node === 'string') {\n return {\n $el: 'text',\n children: node,\n };\n }\n if (isSugar(node)) {\n const { $formkit: type, for: iterator, if: condition, children, bind, ...props } = node;\n return Object.assign({\n $cmp: 'FormKit',\n props: { ...props, type },\n }, condition ? { if: condition } : {}, iterator ? { for: iterator } : {}, children ? { children } : {}, bind ? { bind } : {});\n }\n return node;\n}\n\n/**\n * Compiles a logical string like \"a != z || b == c\" into a single function.\n * The return value is an object with a \"provide\" method that iterates over all\n * requirement tokens to use as replacements.\n * ```typescript\n * let name = {\n * value: 'jon'\n * }\n * const condition = compile(\"$name == 'bob'\").provide((token) => {\n * return () => name.value // must return a function!\n * })\n *\n * condition() // false\n * ```\n * @param expr - A string to compile\n * @returns\n * @public\n */\nfunction compile(expr) {\n /**\n * These tokens are replacements used in evaluating a given condition.\n */\n // const tokens: FormKitTokens = {}\n /**\n * The value of the provide() callback. Used for late binding.\n */\n let provideTokens;\n /**\n * These are token requirements like \"$name.value\" that are need to fulfill\n * a given condition call.\n */\n const requirements = new Set();\n /**\n * Expands the current value if it is a function.\n * @param operand - A left or right hand operand\n * @returns\n */\n const x = function expand(operand, tokens) {\n return typeof operand === 'function' ? operand(tokens) : operand;\n };\n /**\n * Comprehensive list of operators. This list MUST be\n * ordered by the length of the operator characters in descending order.\n */\n const operatorRegistry = [\n {\n '&&': (l, r, t) => x(l, t) && x(r, t),\n '||': (l, r, t) => x(l, t) || x(r, t),\n },\n {\n '===': (l, r, t) => !!(x(l, t) === x(r, t)),\n '!==': (l, r, t) => !!(x(l, t) !== x(r, t)),\n '==': (l, r, t) => !!(x(l, t) == x(r, t)),\n '!=': (l, r, t) => !!(x(l, t) != x(r, t)),\n '>=': (l, r, t) => !!(x(l, t) >= x(r, t)),\n '<=': (l, r, t) => !!(x(l, t) <= x(r, t)),\n '>': (l, r, t) => !!(x(l, t) > x(r, t)),\n '<': (l, r, t) => !!(x(l, t) < x(r, t)),\n },\n {\n '+': (l, r, t) => x(l, t) + x(r, t),\n '-': (l, r, t) => x(l, t) - x(r, t),\n },\n {\n '*': (l, r, t) => x(l, t) * x(r, t),\n '/': (l, r, t) => x(l, t) / x(r, t),\n '%': (l, r, t) => x(l, t) % x(r, t),\n },\n ];\n /**\n * A full list of all operator symbols.\n */\n const operatorSymbols = operatorRegistry.reduce((s, g) => {\n return s.concat(Object.keys(g));\n }, []);\n /**\n * An array of the first character of each operator.\n */\n const operatorChars = new Set(operatorSymbols.map((key) => key.charAt(0)));\n /**\n * Determines if the current character is the start of an operator symbol, if it\n * is, it returns that symbol.\n * @param symbols - An array of symbols that are considered operators\n * @param char - The current character being operated on\n * @param p - The position of the pointer\n * @param expression - The full string expression\n * @returns\n */\n function getOp(symbols, char, p, expression) {\n const candidates = symbols.filter((s) => s.startsWith(char));\n if (!candidates.length)\n return false;\n return candidates.find((symbol) => {\n if (expression.length >= p + symbol.length) {\n const nextChars = expression.substring(p, p + symbol.length);\n if (nextChars === symbol)\n return symbol;\n }\n return false;\n });\n }\n /**\n * Determines the step number of the right or left hand operator.\n * @param p - The position of the pointer\n * @param expression - The full string expression\n * @param direction - 1 = right, 0 = left\n */\n function getStep(p, expression, direction = 1) {\n let next = direction\n ? expression.substring(p + 1).trim()\n : expression.substring(0, p).trim();\n if (!next.length)\n return -1;\n if (!direction) {\n // left hand direction could include a function name we need to remove\n const reversed = next.split('').reverse();\n const start = reversed.findIndex((char) => operatorChars.has(char));\n next = reversed.slice(start).join('');\n }\n const char = next[0];\n return operatorRegistry.findIndex((operators) => {\n const symbols = Object.keys(operators);\n return !!getOp(symbols, char, 0, next);\n });\n }\n /**\n * Extracts a tail call. For example:\n * ```\n * $foo().bar(baz) + 7\n * ```\n * Would extract \"bar(baz)\" and return p of 15 (after the (baz)).\n *\n * @param p - The position of a closing parenthetical.\n * @param expression - The full expression being parsed.\n */\n function getTail(pos, expression) {\n let tail = '';\n const length = expression.length;\n let depth = 0;\n for (let p = pos; p < length; p++) {\n const char = expression.charAt(p);\n if (char === '(') {\n depth++;\n }\n else if (char === ')') {\n depth--;\n }\n else if (depth === 0 && char === ' ') {\n continue;\n }\n if (depth === 0 && getOp(operatorSymbols, char, p, expression)) {\n return [tail, p - 1];\n }\n else {\n tail += char;\n }\n }\n return [tail, expression.length - 1];\n }\n /**\n * Parse a string expression into a function that returns a boolean. This is\n * the magic behind schema logic like $if.\n * @param expression - A string expression to parse\n * @returns\n */\n function parseLogicals(expression, step = 0) {\n const operators = operatorRegistry[step];\n const length = expression.length;\n const symbols = Object.keys(operators);\n let depth = 0;\n let quote = false;\n let op = null;\n let operand = '';\n let left = null;\n let operation;\n let lastChar = '';\n let char = '';\n let parenthetical = '';\n let parenQuote = '';\n let startP = 0;\n const addTo = (depth, char) => {\n depth ? (parenthetical += char) : (operand += char);\n };\n for (let p = 0; p < length; p++) {\n lastChar = char;\n char = expression.charAt(p);\n if ((char === \"'\" || char === '\"') &&\n lastChar !== '\\\\' &&\n ((depth === 0 && !quote) || (depth && !parenQuote))) {\n if (depth) {\n parenQuote = char;\n }\n else {\n quote = char;\n }\n addTo(depth, char);\n continue;\n }\n else if ((quote && (char !== quote || lastChar === '\\\\')) ||\n (parenQuote && (char !== parenQuote || lastChar === '\\\\'))) {\n addTo(depth, char);\n continue;\n }\n else if (quote === char) {\n quote = false;\n addTo(depth, char);\n continue;\n }\n else if (parenQuote === char) {\n parenQuote = false;\n addTo(depth, char);\n continue;\n }\n else if (char === ' ') {\n continue;\n }\n else if (char === '(') {\n if (depth === 0) {\n startP = p;\n }\n else {\n parenthetical += char;\n }\n depth++;\n }\n else if (char === ')') {\n depth--;\n if (depth === 0) {\n // Parenthetical statements cannot be grouped up in the implicit order\n // of left/right statements based on which step they are on because\n // they are parsed on every step and then must be applied to the\n // operator. Example:\n //\n // 5 + (3) * 2\n //\n // This should yield 11 not 16. This order is normally implicit in the\n // sequence of operators being parsed, but with parenthesis the parse\n // happens each time. Instead we need to know if the resulting value\n // should be applied to the left or the right hand operator. The\n // general algorithm is:\n //\n // 1. Does this paren have an operator on the left or right side\n // 2. If not, it's unnecessarily wrapped (3 + 2)\n // 3. If it does, then which order of operation is highest?\n // 4. Wait for the highest order of operation to bind to an operator.\n // If the parenthetical has a preceding token like $fn(1 + 2) then we\n // need to subtract the existing operand length from the start\n // to determine if this is a left or right operation\n const fn = typeof operand === 'string' && operand.startsWith('$')\n ? operand\n : undefined;\n const hasTail = fn && expression.charAt(p + 1) === '.';\n // It's possible the function has a chained tail call:\n let tail = '';\n if (hasTail) {\n [tail, p] = getTail(p + 2, expression);\n }\n const lStep = op ? step : getStep(startP, expression, 0);\n const rStep = getStep(p, expression);\n if (lStep === -1 && rStep === -1) {\n // This parenthetical was unnecessarily wrapped at the root, or\n // these are args of a function call.\n operand = evaluate(parenthetical, -1, fn, tail);\n }\n else if (op && (lStep >= rStep || rStep === -1) && step === lStep) {\n // has a left hand operator with a higher order of operation\n left = op.bind(null, evaluate(parenthetical, -1, fn, tail));\n op = null;\n operand = '';\n }\n else if (rStep > lStep && step === rStep) {\n // should be applied to the right hand operator when it gets one\n operand = evaluate(parenthetical, -1, fn, tail);\n }\n else {\n operand += `(${parenthetical})${hasTail ? `.${tail}` : ''}`;\n }\n parenthetical = '';\n }\n else {\n parenthetical += char;\n }\n }\n else if (depth === 0 &&\n (operation = getOp(symbols, char, p, expression))) {\n if (p === 0) {\n error(103, [operation, expression]);\n }\n // We identified the operator by looking ahead in the string, so we need\n // our position to move past the operator\n p += operation.length - 1;\n if (p === expression.length - 1) {\n error(104, [operation, expression]);\n }\n if (!op) {\n // Bind the left hand operand\n if (left) {\n // In this case we've already parsed the left hand operator\n op = operators[operation].bind(null, evaluate(left, step));\n left = null;\n }\n else {\n op = operators[operation].bind(null, evaluate(operand, step));\n operand = '';\n }\n }\n else if (operand) {\n // Bind the right hand operand, and return the resulting expression as a new left hand operator\n left = op.bind(null, evaluate(operand, step));\n op = operators[operation].bind(null, left);\n operand = '';\n }\n continue;\n }\n else {\n addTo(depth, char);\n }\n }\n if (operand && op) {\n // If we were left with an operand after the loop, and an op, it should\n // be the right hand assignment.\n op = op.bind(null, evaluate(operand, step));\n }\n // If we don't have an op, but we do have a left hand assignment, then that\n // is actually our operator, so just re-assign it to op\n op = !op && left ? left : op;\n if (!op && operand) {\n // If we don't have any op but we do have an operand so there is no boolean\n // logic to perform, but that operand still means something so we need to\n // evaluate it and return it as a function\n op = (v, t) => {\n return typeof v === 'function' ? v(t) : v;\n };\n op = op.bind(null, evaluate(operand, step));\n }\n if (!op && !operand) {\n error(105, expression);\n }\n return op;\n }\n /**\n * Given a string like '$name==bobby' evaluate it to true or false\n * @param operand - A left or right boolean operand — usually conditions\n * @param step - The current order of operation\n * @param fnToken - The token (string) representation of a function being called\n * @returns\n */\n function evaluate(operand, step, fnToken, tail //eslint-disable-line\n ) {\n if (fnToken) {\n const fn = evaluate(fnToken, operatorRegistry.length);\n let userFuncReturn;\n // \"Tail calls\" are dot accessors after a function $foo().value. We need\n // to compile tail calls, and then provide the function result to the\n // exposed tokens.\n let tailCall = tail\n ? compile(`$${tail}`)\n : false;\n if (typeof fn === 'function') {\n const args = parseArgs(String(operand)).map((arg) => evaluate(arg, -1));\n return (tokens) => {\n const userFunc = fn(tokens);\n if (typeof userFunc !== 'function') {\n warn(150, fnToken);\n return userFunc;\n }\n userFuncReturn = userFunc(...args.map((arg) => typeof arg === 'function' ? arg(tokens) : arg));\n if (tailCall) {\n tailCall = tailCall.provide((subTokens) => {\n const rootTokens = provideTokens(subTokens);\n const t = subTokens.reduce((tokenSet, token) => {\n const isTail = token === tail || (tail === null || tail === void 0 ? void 0 : tail.startsWith(`${token}(`));\n if (isTail) {\n const value = getAt(userFuncReturn, token);\n tokenSet[token] = () => value;\n }\n else {\n tokenSet[token] = rootTokens[token];\n }\n return tokenSet;\n }, {});\n return t;\n });\n }\n return tailCall ? tailCall() : userFuncReturn;\n };\n }\n }\n else if (typeof operand === 'string') {\n // the word true or false will never contain further operations\n if (operand === 'true')\n return true;\n if (operand === 'false')\n return false;\n if (operand === 'undefined')\n return undefined;\n // Truly quotes strings cannot contain an operation, return the string\n if (isQuotedString(operand))\n return rmEscapes(operand.substring(1, operand.length - 1));\n // Actual numbers cannot be contain an operation\n if (!isNaN(+operand))\n return Number(operand);\n if (step < operatorRegistry.length - 1) {\n return parseLogicals(operand, step + 1);\n }\n else {\n if (operand.startsWith('$')) {\n const cleaned = operand.substring(1);\n requirements.add(cleaned);\n return function getToken(tokens) {\n return cleaned in tokens ? tokens[cleaned]() : undefined;\n };\n }\n // In this case we are dealing with an unquoted string, just treat it\n // as a plain string.\n return operand;\n }\n }\n return operand;\n }\n /**\n * Compile the string.\n */\n const compiled = parseLogicals(expr.startsWith('$:') ? expr.substring(2) : expr);\n /**\n * Convert compiled requirements to an array.\n */\n const reqs = Array.from(requirements);\n /**\n * Provides token values via callback to compiled output.\n * @param callback - A callback that needs to provide all token requirements\n * @returns\n */\n function provide(callback) {\n provideTokens = callback;\n return Object.assign(compiled.bind(null, callback(reqs)), {\n provide,\n });\n }\n return Object.assign(compiled, {\n provide,\n });\n}\n\n/**\n * Function that produces a standardized object representation of CSS classes\n * @param propertyKey - section key\n * @param node - FormKit node\n * @param sectionClassList - Things to turn into classes\n * @returns\n * @public\n */\nfunction createClasses(propertyKey, node, sectionClassList) {\n if (!sectionClassList)\n return {};\n if (typeof sectionClassList === 'string') {\n const classKeys = sectionClassList.split(' ');\n return classKeys.reduce((obj, key) => Object.assign(obj, { [key]: true }), {});\n }\n else if (typeof sectionClassList === 'function') {\n return createClasses(propertyKey, node, sectionClassList(node, propertyKey));\n }\n return sectionClassList;\n}\n/**\n * Combines multiple class lists into a single list\n * @param node - the FormKit node being operated on\n * @param property - The property key to which the class list will be applied\n * @param args - CSS class list(s)\n * @returns\n * @public\n */\nfunction generateClassList(node, property, ...args) {\n const combinedClassList = args.reduce((finalClassList, currentClassList) => {\n if (!currentClassList)\n return finalClassList;\n const { $reset, ...classList } = currentClassList;\n if ($reset) {\n return classList;\n }\n return Object.assign(finalClassList, classList);\n }, {});\n return (Object.keys(node.hook.classes.dispatch({ property, classes: combinedClassList })\n .classes)\n .filter((key) => combinedClassList[key])\n .join(' ') || null);\n}\n\n/**\n * Sets errors on a form, group, or input.\n * @param formId - The id of a form\n * @param localErrors - The errors to set on the form or the form’s inputs\n * @param childErrors - (optional) The errors to set on the form or the form’s inputs\n * @public\n */\nfunction setErrors(id, localErrors, childErrors) {\n const node = getNode$1(id);\n if (node) {\n node.setErrors(localErrors, childErrors);\n }\n else {\n warn(651, id);\n }\n}\n/**\n * Clears child errors.\n * @param id - The id of the node you want to clear errors for\n * @param clearChildren - Determines if the the children of this node should have their errors cleared.\n * @public\n */\nfunction clearErrors(id, clearChildren = true) {\n const node = getNode$1(id);\n if (node) {\n node.clearErrors(clearChildren);\n }\n else {\n warn(652, id);\n }\n}\n\n/**\n * index.ts\n *\n * In this file we explicitly declare what should end up in the public API.\n */\n/**\n * The current version of FormKit at the time the package is published. Is replaced\n * as part of the publishing script.\n * @public\n */\nconst FORMKIT_VERSION = '1.0.0-beta.12';\n\nexport { FORMKIT_VERSION, bfs, clearErrors, compile, createClasses, createConfig$1 as createConfig, createMessage, createNode, createValue, deregister, error, errorHandler, generateClassList, getNode$1 as getNode, isComponent, isConditional, isDOM, isList, isNode, isSugar, names, register, reset, resetCount, resetRegistry, setErrors, submitForm, sugar, use, useIndex, valueInserted, valueMoved, valueRemoved, warn, warningHandler, watchRegistry };\n","import { extend, camel, has, isPojo, eq, kebab, undefine, clone, isObject } from '@formkit/utils';\nimport { createMessage, warn, isConditional, isDOM, isComponent } from '@formkit/core';\n\n/**\n *\n * @param libraries - One or many formkit urls.\n * @returns\n * @public\n */\nfunction createLibraryPlugin(...libraries) {\n /**\n * Merge all provided library items.\n */\n const library = libraries.reduce((merged, lib) => extend(merged, lib), {});\n /* eslint-disable-next-line @typescript-eslint/no-empty-function */\n const plugin = () => { };\n /**\n * Enables the hook that exposes all library inputs.\n * @param node - The primary plugin\n */\n plugin.library = function (node) {\n const type = camel(node.props.type);\n if (has(library, type)) {\n node.define(library[type]);\n }\n };\n return plugin;\n}\n\n/**\n * Accepts an array of objects, array of strings, or object of key-value pairs.\n * and returns an array of objects with value and label properties.\n * @param options - Options to normalize\n * @public\n */\nfunction normalizeOptions(options) {\n let i = 1;\n if (Array.isArray(options)) {\n return options.map((option) => {\n if (typeof option === 'string' || typeof option === 'number') {\n return {\n label: String(option),\n value: String(option),\n };\n }\n if (typeof option == 'object') {\n if ('value' in option && typeof option.value !== 'string') {\n Object.assign(option, {\n value: `__mask_${i++}`,\n __original: option.value,\n });\n }\n }\n return option;\n });\n }\n return Object.keys(options).map((value) => {\n return {\n label: options[value],\n value,\n };\n });\n}\n/**\n * Given an option list, find the \"true\" value in the options.\n * @param options - The options to check for a given value\n * @param value - The value to return\n * @returns\n */\nfunction optionValue(options, value) {\n if (Array.isArray(options)) {\n for (const option of options) {\n if (value == option.value) {\n return '__original' in option ? option.__original : option.value;\n }\n }\n }\n return value;\n}\n/**\n * Determines if the value should be selected.\n * @param valueA - Any type of value\n * @param valueB - Any type of value\n */\nfunction shouldSelect(valueA, valueB) {\n if (valueA == valueB)\n return true;\n if (isPojo(valueA) && isPojo(valueB))\n return eq(valueA, valueB);\n return false;\n}\n/**\n * Converts the options prop to usable values.\n * @param node - A formkit node.\n * @public\n */\nfunction options(node) {\n node.hook.prop((prop, next) => {\n if (prop.prop === 'options') {\n if (typeof prop.value === 'function') {\n node.props.optionsLoader = prop.value;\n prop.value = [];\n }\n else {\n prop.value = normalizeOptions(prop.value);\n }\n }\n return next(prop);\n });\n}\n\n/**\n * @public\n */\nconst outer = createSection('outer', () => ({\n $el: 'div',\n attrs: {\n key: '$id',\n 'data-family': '$family || undefined',\n 'data-type': '$type',\n 'data-multiple': '$attrs.multiple || ($type != \"select\" && $options != undefined) || undefined',\n 'data-disabled': '$disabled || undefined',\n 'data-complete': '$state.complete || undefined',\n 'data-invalid': '$state.valid === false && $state.validationVisible || undefined',\n 'data-errors': '$state.errors || undefined',\n 'data-submitted': '$state.submitted || undefined',\n 'data-prefix-icon': '$_rawPrefixIcon !== undefined || undefined',\n 'data-suffix-icon': '$_rawSuffixIcon !== undefined || undefined',\n 'data-prefix-icon-click': '$onPrefixIconClick !== undefined || undefined',\n 'data-suffix-icon-click': '$onSuffixIconClick !== undefined || undefined',\n },\n}), true);\n\n/**\n * @public\n */\nconst inner = createSection('inner', 'div');\n\n/**\n * @public\n */\nconst wrapper = createSection('wrapper', 'div');\n\n/**\n * @public\n */\nconst label = createSection('label', () => ({\n $el: 'label',\n if: '$label',\n attrs: {\n for: '$id',\n },\n}));\n\n/**\n * @public\n */\nconst messages = createSection('messages', () => ({\n $el: 'ul',\n if: '$fns.length($messages)',\n}));\n\n/**\n * @public\n */\nconst message = createSection('message', () => ({\n $el: 'li',\n for: ['message', '$messages'],\n attrs: {\n key: '$message.key',\n id: `$id + '-' + $message.key`,\n 'data-message-type': '$message.type',\n },\n}));\n\n/**\n * @public\n */\nconst prefix = createSection('prefix', null);\n\n/**\n * @public\n */\nconst suffix = createSection('suffix', null);\n\n/**\n * @public\n */\nconst help = createSection('help', () => ({\n $el: 'div',\n if: '$help',\n attrs: {\n id: '$: \"help-\" + $id',\n },\n}));\n\n/**\n * @public\n */\nconst fieldset = createSection('fieldset', () => ({\n $el: 'fieldset',\n attrs: {\n id: '$id',\n 'aria-describedby': {\n if: '$help',\n then: '$: \"help-\" + $id',\n else: undefined,\n },\n },\n}));\n\n/**\n * @public\n */\nconst decorator = createSection('decorator', () => ({\n $el: 'span',\n attrs: {\n 'aria-hidden': 'true',\n },\n}));\n\n/**\n * @public\n */\nconst box = createSection('input', () => ({\n $el: 'input',\n bind: '$attrs',\n attrs: {\n type: '$type',\n name: '$node.props.altName || $node.name',\n disabled: '$option.attrs.disabled || $disabled',\n onInput: '$handlers.toggleChecked',\n checked: '$fns.eq($_value, $onValue)',\n onBlur: '$handlers.blur',\n value: '$: true',\n id: '$id',\n 'aria-describedby': {\n if: '$options.length',\n then: {\n if: '$option.help',\n then: '$: \"help-\" + $option.attrs.id',\n else: undefined,\n },\n else: {\n if: '$help',\n then: '$: \"help-\" + $id',\n else: undefined,\n },\n },\n },\n}));\n\n/**\n * @public\n */\nconst legend = createSection('legend', () => ({\n $el: 'legend',\n if: '$label',\n}));\n\n/**\n * @public\n */\nconst boxOption = createSection('option', () => ({\n $el: 'li',\n for: ['option', '$options'],\n attrs: {\n 'data-disabled': '$option.attrs.disabled || $disabled',\n },\n}));\n\n/**\n * @public\n */\nconst boxOptions = createSection('options', 'ul');\n\n/**\n * @public\n */\nconst boxWrapper = createSection('wrapper', () => ({\n $el: 'label',\n attrs: {\n 'data-disabled': {\n if: '$options.length',\n then: undefined,\n else: '$disabled || undefined',\n },\n },\n}));\n\n/**\n * @public\n */\nconst boxHelp = createSection('optionHelp', () => ({\n $el: 'div',\n if: '$option.help',\n attrs: {\n id: '$: \"help-\" + $option.attrs.id',\n },\n}));\n\n/**\n * @public\n */\nconst boxLabel = createSection('label', 'span');\n\n/**\n * @public\n */\nconst buttonInput = createSection('input', () => ({\n $el: 'button',\n bind: '$attrs',\n attrs: {\n type: '$type',\n disabled: '$disabled',\n name: '$node.name',\n id: '$id',\n },\n}));\n\n/**\n * @public\n */\nconst buttonLabel = createSection('default', null);\n\n/**\n * @public\n */\nconst fileInput = createSection('input', () => ({\n $el: 'input',\n bind: '$attrs',\n attrs: {\n type: 'file',\n disabled: '$disabled',\n name: '$node.name',\n onChange: '$handlers.files',\n onBlur: '$handlers.blur',\n id: '$id',\n 'aria-describedby': '$describedBy',\n },\n}));\n\n/**\n * @public\n */\nconst fileItem = createSection('fileItem', () => ({\n $el: 'li',\n for: ['file', '$value'],\n}));\n\n/**\n * @public\n */\nconst fileList = createSection('fileList', () => ({\n $el: 'ul',\n if: '$value.length',\n attrs: {\n 'data-has-multiple': {\n if: '$value.length > 1',\n then: 'true',\n },\n },\n}));\n\n/**\n * @public\n */\nconst fileName = createSection('fileName', () => ({\n $el: 'span',\n attrs: {\n class: '$classes.fileName',\n },\n}));\n\n/**\n * @public\n */\nconst fileRemove = createSection('fileRemove', () => ({\n $el: 'button',\n attrs: {\n onClick: '$handlers.resetFiles',\n },\n}));\n\n/**\n * @public\n */\nconst noFiles = createSection('noFiles', () => ({\n $el: 'span',\n if: '$value.length == 0',\n}));\n\n/**\n * @public\n */\nconst formInput = createSection('form', () => ({\n $el: 'form',\n bind: '$attrs',\n attrs: {\n id: '$id',\n name: '$node.name',\n onSubmit: '$handlers.submit',\n 'data-loading': '$state.loading || undefined',\n },\n}), true);\n\n/**\n * @public\n */\nconst actions = createSection('actions', () => ({\n $el: 'div',\n if: '$actions',\n}));\n\n/**\n * @public\n */\nconst submitInput = createSection('submit', () => ({\n $cmp: 'FormKit',\n bind: '$submitAttrs',\n props: {\n ignore: true,\n type: 'submit',\n disabled: '$disabled',\n label: '$submitLabel',\n },\n}));\n\n/**\n * @public\n */\nconst textInput = createSection('input', () => ({\n $el: 'input',\n bind: '$attrs',\n attrs: {\n type: '$type',\n disabled: '$disabled',\n name: '$node.name',\n onInput: '$handlers.DOMInput',\n onBlur: '$handlers.blur',\n value: '$_value',\n id: '$id',\n 'aria-describedby': '$describedBy',\n },\n}));\n\n/**\n * @public\n */\nconst fragment = createSection('wrapper', null, true);\n\n/**\n * @public\n */\nconst selectInput$1 = createSection('input', () => ({\n $el: 'select',\n bind: '$attrs',\n attrs: {\n id: '$id',\n 'data-placeholder': '$fns.showPlaceholder($_value, $placeholder)',\n disabled: '$disabled',\n class: '$classes.input',\n name: '$node.name',\n onChange: '$handlers.onChange',\n onInput: '$handlers.selectInput',\n onBlur: '$handlers.blur',\n 'aria-describedby': '$describedBy',\n },\n}));\n\n/**\n * @public\n */\nconst option = createSection('option', () => ({\n $el: 'option',\n for: ['option', '$options'],\n bind: '$option.attrs',\n attrs: {\n class: '$classes.option',\n value: '$option.value',\n selected: '$fns.isSelected($option)',\n },\n}));\n\n/**\n * @public\n */\nconst optionSlot = () => ({\n $el: null,\n if: '$options.length',\n for: ['option', '$options'],\n children: '$slots.option',\n});\n\n/**\n * @public\n */\nconst textareaInput = createSection('input', () => ({\n $el: 'textarea',\n bind: '$attrs',\n attrs: {\n disabled: '$disabled',\n name: '$node.name',\n onInput: '$handlers.DOMInput',\n onBlur: '$handlers.blur',\n value: '$_value',\n id: '$id',\n 'aria-describedby': '$describedBy',\n },\n children: '$initialValue',\n}));\n\n/**\n * @public\n */\nconst icon = (sectionKey, el) => {\n return createSection(`${sectionKey}Icon`, () => {\n const rawIconProp = `_raw${sectionKey\n .charAt(0)\n .toUpperCase()}${sectionKey.slice(1)}Icon`;\n return {\n if: `$${sectionKey}Icon && $${rawIconProp}`,\n $el: `${el ? el : 'span'}`,\n attrs: {\n class: `$classes.${sectionKey}Icon + \" formkit-icon\"`,\n innerHTML: `$${rawIconProp}`,\n onClick: `$handlers.iconClick(${sectionKey})`,\n for: {\n if: `${el === 'label'}`,\n then: '$id',\n },\n },\n };\n })();\n};\n\n/**\n * Normalize the boxes.\n * @param node - The node\n * @returns\n * @public\n */\nfunction normalizeBoxes(node) {\n return function (prop, next) {\n if (prop.prop === 'options' && Array.isArray(prop.value)) {\n prop.value = prop.value.map((option) => {\n var _a;\n if (!((_a = option.attrs) === null || _a === void 0 ? void 0 : _a.id)) {\n return extend(option, {\n attrs: { id: `${node.name}-option-${kebab(String(option.value))}` },\n });\n }\n return option;\n });\n if (node.props.type === 'checkbox' && !Array.isArray(node.value)) {\n if (node.isCreated) {\n node.input([], false);\n }\n else {\n node.on('created', () => {\n if (!Array.isArray(node.value)) {\n node.input([], false);\n }\n });\n }\n }\n }\n return next(prop);\n };\n}\n\n/**\n * Event handler when an input is toggled.\n * @param node - The node being toggled\n * @param e - The input even related to the toggling\n * @public\n */\nfunction toggleChecked$1(node, e) {\n const el = e.target;\n if (el instanceof HTMLInputElement) {\n const value = Array.isArray(node.props.options)\n ? optionValue(node.props.options, el.value)\n : el.value;\n if (Array.isArray(node.props.options) && node.props.options.length) {\n if (!Array.isArray(node._value)) {\n // There is no array value set\n node.input([value]);\n }\n else if (!node._value.some((existingValue) => shouldSelect(value, existingValue))) {\n // The value is not in the current set\n node.input([...node._value, value]);\n }\n else {\n // Filter out equivalent values\n node.input(node._value.filter((existingValue) => !shouldSelect(value, existingValue)));\n }\n }\n else {\n if (el.checked) {\n node.input(node.props.onValue);\n }\n else {\n node.input(node.props.offValue);\n }\n }\n }\n}\n/**\n * Checks if a given option is present in the node value.\n * @param node - The node being checked\n * @param value - The value of any option\n * @returns\n */\nfunction isChecked$1(node, value) {\n var _a, _b;\n // We need to force vue’s reactivity to respond when the value is run:\n (_a = node.context) === null || _a === void 0 ? void 0 : _a.value;\n (_b = node.context) === null || _b === void 0 ? void 0 : _b._value;\n if (Array.isArray(node._value)) {\n return node._value.some((existingValue) => shouldSelect(optionValue(node.props.options, value), existingValue));\n }\n return false;\n}\n/**\n * Adds checkbox selection support\n * @param node - Node the feature is added to\n * @public\n */\nfunction checkboxes(node) {\n node.on('created', () => {\n var _a, _b;\n if ((_a = node.context) === null || _a === void 0 ? void 0 : _a.handlers) {\n node.context.handlers.toggleChecked = toggleChecked$1.bind(null, node);\n }\n if ((_b = node.context) === null || _b === void 0 ? void 0 : _b.fns) {\n node.context.fns.isChecked = isChecked$1.bind(null, node);\n }\n // Configure our default onValue and offValue\n if (!has(node.props, 'onValue'))\n node.props.onValue = true;\n if (!has(node.props, 'offValue'))\n node.props.offValue = false;\n });\n node.hook.prop(normalizeBoxes(node));\n}\n\n/**\n * Allows disabling children of this.\n * @param node - The FormKitNode of the form/group/list\n * @public\n */\nfunction disables(node) {\n node.on('created', () => {\n node.props.disabled = undefine(node.props.disabled);\n });\n node.hook.prop(({ prop, value }, next) => {\n value = prop === 'disabled' ? undefine(value) : value;\n return next({ prop, value });\n });\n node.on('prop:disabled', ({ payload: value }) => {\n node.config.disabled = undefine(value);\n });\n node.on('created', () => {\n node.config.disabled = undefine(node.props.disabled);\n });\n}\n\n/**\n * Creates a new feature that generates a localization message of type ui\n * for use on a given component.\n *\n * @param key - The key of the message\n * @param value - The value of the message\n * @returns\n * @public\n */\nfunction localize(key, value) {\n return (node) => {\n node.store.set(createMessage({\n key,\n type: 'ui',\n value: value || key,\n meta: {\n localize: true,\n i18nArgs: [node],\n },\n }));\n };\n}\n\nconst isBrowser = typeof window !== 'undefined';\n/**\n * Remove the data-file-hover attribute from the target.\n * @param e - Event\n */\nfunction removeHover(e) {\n if (e.target instanceof HTMLElement &&\n e.target.hasAttribute('data-file-hover')) {\n e.target.removeAttribute('data-file-hover');\n }\n}\n/**\n * Prevent stray drag/drop events from navigating the window.\n * @param e - Event\n * @public\n */\nfunction preventStrayDrop(type, e) {\n if (!(e.target instanceof HTMLInputElement)) {\n e.preventDefault();\n }\n else if (type === 'dragover') {\n e.target.setAttribute('data-file-hover', 'true');\n }\n if (type === 'drop') {\n removeHover(e);\n }\n}\n/**\n * Feature to add file handling support to an input.\n * @param node - The node being checked\n * @public\n */\nfunction files(node) {\n // Localize our content:\n localize('noFiles', 'Select file')(node);\n localize('removeAll', 'Remove all')(node);\n localize('remove')(node);\n if (isBrowser) {\n if (!window._FormKit_File_Drop) {\n window.addEventListener('dragover', preventStrayDrop.bind(null, 'dragover'));\n window.addEventListener('drop', preventStrayDrop.bind(null, 'drop'));\n window.addEventListener('dragleave', removeHover);\n window._FormKit_File_Drop = true;\n }\n }\n node.hook.input((value, next) => next(Array.isArray(value) ? value : []));\n node.on('created', () => {\n if (!Array.isArray(node.value))\n node.input([], false);\n if (!node.context)\n return;\n node.context.handlers.resetFiles = (e) => {\n e.preventDefault();\n node.input([]);\n if (node.props.id && isBrowser) {\n const el = document.getElementById(node.props.id);\n if (el)\n el.value = '';\n }\n };\n node.context.handlers.files = (e) => {\n var _a, _b;\n const files = [];\n if (e.target instanceof HTMLInputElement && e.target.files) {\n for (let i = 0; i < e.target.files.length; i++) {\n let file;\n if ((file = e.target.files.item(i))) {\n files.push({ name: file.name, file });\n }\n }\n node.input(files);\n }\n if (node.context)\n node.context.files = files;\n // Call the original listener if there is one.\n if (typeof ((_a = node.props.attrs) === null || _a === void 0 ? void 0 : _a.onChange) === 'function') {\n (_b = node.props.attrs) === null || _b === void 0 ? void 0 : _b.onChange(e);\n }\n };\n });\n}\n\n/**\n * Handle the submit event.\n * @param e - The event\n * @public\n */\nasync function handleSubmit(node, submitEvent) {\n submitEvent.preventDefault();\n await node.settled;\n // Set the submitted state on all children\n node.walk((n) => {\n n.store.set(createMessage({\n key: 'submitted',\n value: true,\n visible: false,\n }));\n });\n if (typeof node.props.onSubmitRaw === 'function') {\n node.props.onSubmitRaw(submitEvent, node);\n }\n if (node.ledger.value('blocking')) {\n if (typeof node.props.onSubmitInvalid === 'function') {\n node.props.onSubmitInvalid(node);\n }\n // There is still a blocking message in the store.\n if (node.props.incompleteMessage !== false) {\n node.store.set(createMessage({\n blocking: false,\n key: `incomplete`,\n meta: {\n localize: node.props.incompleteMessage === undefined,\n i18nArgs: [{ node }],\n showAsMessage: true,\n },\n type: 'ui',\n value: node.props.incompleteMessage || 'Form incomplete.',\n }));\n }\n }\n else {\n // No blocking messages\n if (typeof node.props.onSubmit === 'function') {\n // call onSubmit\n const retVal = node.props.onSubmit(node.hook.submit.dispatch(clone(node.value)), node);\n if (retVal instanceof Promise) {\n const autoDisable = node.props.disabled === undefined &&\n node.props.submitBehavior !== 'live';\n if (autoDisable)\n node.props.disabled = true;\n node.store.set(createMessage({\n key: 'loading',\n value: true,\n visible: false,\n }));\n await retVal;\n if (autoDisable)\n node.props.disabled = false;\n node.store.remove('loading');\n }\n }\n else {\n if (submitEvent.target instanceof HTMLFormElement) {\n submitEvent.target.submit();\n }\n }\n }\n}\n/**\n * Converts the options prop to usable values.\n * @param node - A formkit node.\n * @public\n */\nfunction form$1(node) {\n node.props.isForm = true;\n node.on('created', () => {\n var _a;\n if ((_a = node.context) === null || _a === void 0 ? void 0 : _a.handlers) {\n node.context.handlers.submit = handleSubmit.bind(null, node);\n }\n if (!has(node.props, 'actions')) {\n node.props.actions = true;\n }\n });\n node.on('settled:blocking', () => node.store.remove('incomplete'));\n}\n\n/**\n * Applies ignore=\"true\" by default.\n * @param node - The node\n * @public\n */\nfunction ignore(node) {\n if (node.props.ignore === undefined) {\n node.props.ignore = true;\n node.parent = null;\n }\n}\n\n/**\n * Ensures the input has an `initialValue` prop.\n * @param node - The node being given an initial value\n * @public\n */\nfunction initialValue(node) {\n node.on('created', () => {\n if (node.context) {\n node.context.initialValue = node.value || '';\n }\n });\n}\n\n/**\n * Sets the value of a radio button when checked.\n * @param node - FormKitNode\n * @param value - Value\n * @public\n */\nfunction toggleChecked(node, event) {\n if (event.target instanceof HTMLInputElement) {\n node.input(optionValue(node.props.options, event.target.value));\n }\n}\n/**\n * Checks if the value being checked is the current value.\n * @param node - The node to check against.\n * @param value - The value to check\n * @returns\n */\nfunction isChecked(node, value) {\n var _a, _b;\n // We need to force vue’s reactivity to respond when the value is run:\n (_a = node.context) === null || _a === void 0 ? void 0 : _a.value;\n (_b = node.context) === null || _b === void 0 ? void 0 : _b._value;\n return shouldSelect(optionValue(node.props.options, value), node._value);\n}\n/**\n * Determines if a given radio input is being evaluated.\n * @param node - The radio input group.\n * @public\n */\nfunction radios(node) {\n node.on('created', () => {\n var _a, _b;\n if (!Array.isArray(node.props.options)) {\n warn(350, node);\n }\n if ((_a = node.context) === null || _a === void 0 ? void 0 : _a.handlers) {\n node.context.handlers.toggleChecked = toggleChecked.bind(null, node);\n }\n if ((_b = node.context) === null || _b === void 0 ? void 0 : _b.fns) {\n node.context.fns.isChecked = isChecked.bind(null, node);\n }\n });\n node.hook.prop(normalizeBoxes(node));\n}\n\n/**\n * Checks if a the given option should have the selected attribute.\n * @param node - The node being evaluated.\n * @param option - The option value to check\n * @returns\n * @public\n */\nfunction isSelected(node, option) {\n // Here we trick reactivity (if at play) to watch this function.\n node.context && node.context.value;\n const optionValue = '__original' in option ? option.__original : option.value;\n function hasNoNullOption() {\n return !node.props.options.some((option) => ('__original' in option ? option.__original : option.value) === null);\n }\n return Array.isArray(node._value)\n ? node._value.some((optionA) => shouldSelect(optionA, optionValue))\n : (node._value === undefined ||\n (node._value === null && hasNoNullOption())) &&\n option.attrs &&\n option.attrs['data-is-placeholder']\n ? true\n : shouldSelect(optionValue, node._value);\n}\n/**\n * Defers the change event till after the next cycle.\n * @param node - The node being evaluated.\n * @param e - The change event.\n */\nasync function deferChange(node, e) {\n var _a;\n if (typeof ((_a = node.props.attrs) === null || _a === void 0 ? void 0 : _a.onChange) === 'function') {\n await new Promise((r) => setTimeout(r, 0));\n await node.settled;\n node.props.attrs.onChange(e);\n }\n}\n/**\n * Select the correct values.\n * @param e - The input event emitted by the select.\n */\nfunction selectInput(node, e) {\n const target = e.target;\n const value = target.hasAttribute('multiple')\n ? Array.from(target.selectedOptions).map((o) => optionValue(node.props.options, o.value))\n : optionValue(node.props.options, target.value);\n node.input(value);\n}\n/**\n * Appends a placeholder to the options list.\n * @param options - An options list\n * @param placeholder - A placeholder string to append\n * @returns\n */\nfunction applyPlaceholder(options, placeholder) {\n if (!options.some((option) => option.attrs && option.attrs['data-is-placeholder'])) {\n return [\n {\n label: placeholder,\n value: '',\n attrs: {\n hidden: true,\n disabled: true,\n 'data-is-placeholder': 'true',\n },\n },\n ...options,\n ];\n }\n return options;\n}\n/**\n * Converts the options prop to usable values.\n * @param node - A formkit node.\n * @public\n */\nfunction select$1(node) {\n // Set the initial value of a multi-input\n node.on('created', () => {\n var _a, _b, _c;\n const isMultiple = undefine((_a = node.props.attrs) === null || _a === void 0 ? void 0 : _a.multiple);\n if (!isMultiple &&\n node.props.placeholder &&\n Array.isArray(node.props.options)) {\n node.hook.prop(({ prop, value }, next) => {\n if (prop === 'options') {\n value = applyPlaceholder(value, node.props.placeholder);\n }\n return next({ prop, value });\n });\n node.props.options = applyPlaceholder(node.props.options, node.props.placeholder);\n }\n if (isMultiple) {\n if (node.value === undefined) {\n node.input([], false);\n }\n }\n else if (node.context && !node.context.options) {\n // If this input is (probably) using the default slot, we need to add a\n // \"value\" attribute to get bound\n node.props.attrs = Object.assign({}, node.props.attrs, {\n value: node._value,\n });\n node.on('input', ({ payload }) => {\n node.props.attrs = Object.assign({}, node.props.attrs, {\n value: payload,\n });\n });\n }\n if ((_b = node.context) === null || _b === void 0 ? void 0 : _b.handlers) {\n node.context.handlers.selectInput = selectInput.bind(null, node);\n node.context.handlers.onChange = deferChange.bind(null, node);\n }\n if ((_c = node.context) === null || _c === void 0 ? void 0 : _c.fns) {\n node.context.fns.isSelected = isSelected.bind(null, node);\n node.context.fns.showPlaceholder = (value, placeholder) => {\n if (!Array.isArray(node.props.options))\n return false;\n const hasMatchingValue = node.props.options.some((option) => {\n if (option.attrs && 'data-is-placeholder' in option.attrs)\n return false;\n const optionValue = '__original' in option ? option.__original : option.value;\n return eq(value, optionValue);\n });\n return placeholder && !hasMatchingValue ? true : undefined;\n };\n }\n });\n node.hook.input((value, next) => {\n var _a, _b, _c;\n if (!node.props.placeholder &&\n value === undefined &&\n Array.isArray((_a = node.props) === null || _a === void 0 ? void 0 : _a.options) &&\n node.props.options.length &&\n !undefine((_c = (_b = node.props) === null || _b === void 0 ? void 0 : _b.attrs) === null || _c === void 0 ? void 0 : _c.multiple)) {\n value =\n '__original' in node.props.options[0]\n ? node.props.options[0].__original\n : node.props.options[0].value;\n }\n return next(value);\n });\n}\n\n/**\n * @param sectionKey - the location the icon should be loaded\n * @param defaultIcon - the icon that should be loaded if a match is found in the user's CSS\n * @public\n */\nfunction defaultIcon(sectionKey, defaultIcon) {\n return (node) => {\n if (node.props[`${sectionKey}Icon`] === undefined) {\n node.props[`${sectionKey}Icon`] = `default:${defaultIcon}`;\n }\n };\n}\n\n/**\n * Type guard for schema objects.\n * @param schema - returns true if the node is a schema node but not a string or conditional.\n * @public\n */\nfunction isSchemaObject(schema) {\n return (typeof schema === 'object' &&\n ('$el' in schema || '$cmp' in schema || '$formkit' in schema));\n}\n/**\n * Checks if the current schema node is a slot condition like:\n * ```js\n * {\n * if: '$slot.name',\n * then: '$slot.name',\n * else: []\n * }\n * ```\n * @param node - a schema node\n * @returns\n * @public\n */\nfunction isSlotCondition(node) {\n if (isConditional(node) &&\n node.if &&\n node.if.startsWith('$slots.') &&\n typeof node.then === 'string' &&\n node.then.startsWith('$slots.') &&\n 'else' in node) {\n return true;\n }\n return false;\n}\n/**\n * Extends a single schema node with an extension. The extension can be any partial node including strings.\n * @param schema - Extend a base schema node.\n * @param extension - The values to extend on the base schema node.\n * @returns\n * @public\n */\nfunction extendSchema(schema, extension = {}) {\n if (typeof schema === 'string') {\n return isSchemaObject(extension) || typeof extension === 'string'\n ? extension\n : schema;\n }\n else if (Array.isArray(schema)) {\n return isSchemaObject(extension) ? extension : schema;\n }\n return extend(schema, extension);\n}\n/**\n * ================================================================\n * NOTE: This function is deprecated. Use `createSection` instead!\n * ================================================================\n *\n * @param key - A new section key name.\n * @param schema - The default schema in this composable slot.\n * @returns\n * @public\n */\nfunction composable(key, schema) {\n warn(800, 'composable function');\n return (extendWith = {}, children = undefined) => {\n const root = typeof schema === 'function'\n ? schema(children)\n : typeof schema === 'object'\n ? clone(schema)\n : schema;\n const isObj = isSchemaObject(root);\n if (isObj && !('children' in root) && children) {\n if (Array.isArray(children)) {\n if (children.length) {\n root.children = children;\n }\n }\n else {\n root.children = [children];\n }\n }\n const extended = extendSchema(root, extendWith);\n return {\n if: `$slots.${key}`,\n then: `$slots.${key}`,\n else: Array.isArray(extended) ? extended : [extended],\n };\n };\n}\n/**\n * Creates an input schema with all of the wrapping base schema.\n * @param inputSchema - Content to store in the input section key location.\n * @public\n */\nfunction useSchema(inputSection) {\n return outer(wrapper(label('$label'), inner(prefix(), inputSection(), suffix())), help('$help'), messages(message('$message.value')));\n}\n/**\n * Creates a new reusable section.\n * @param section - A single section of schema\n * @param el - The element or a function that returns a schema node.\n * @param root - When true returns an extendable root schema node.\n * @returns\n * @public\n */\nfunction createSection(section, el, root = false) {\n return (...children) => {\n const extendable = (extensions) => {\n const node = !el || typeof el === 'string' ? { $el: el } : el();\n if (isDOM(node) || isComponent(node)) {\n if (!node.meta) {\n node.meta = { section };\n }\n if (children.length && !node.children) {\n node.children = [\n ...children.map((child) => typeof child === 'string' ? child : child(extensions)),\n ];\n }\n if (isDOM(node)) {\n node.attrs = {\n class: `$classes.${section}`,\n ...(node.attrs || {}),\n };\n }\n }\n return {\n if: `$slots.${section}`,\n then: `$slots.${section}`,\n else: section in extensions\n ? extendSchema(node, extensions[section])\n : node,\n };\n };\n return root ? createRoot(extendable) : extendable;\n };\n}\n/**\n * Returns an extendable schema root node.\n * @param rootSection - Creates the root node.\n * @returns\n */\nfunction createRoot(rootSection) {\n return (extensions) => {\n return [rootSection(extensions)];\n };\n}\n/**\n * Applies attributes to a given schema section by applying a higher order\n * function that merges a given set of attributes into the node.\n * @param attrs - Apply attributes to a FormKitSchemaExtendableSection\n * @param section - A section to apply attributes to\n * @returns\n * @public\n */\nfunction $attrs(attrs, section) {\n return (extensions) => {\n const node = section(extensions);\n const attributes = typeof attrs === 'function' ? attrs() : attrs;\n if (!isObject(attributes))\n return node;\n if (isSlotCondition(node) && isDOM(node.else)) {\n node.else.attrs = { ...node.else.attrs, ...attributes };\n }\n else if (isDOM(node)) {\n node.attrs = { ...node.attrs, ...attributes };\n }\n return node;\n };\n}\n/**\n *\n * @param condition - A schema condition to apply to a section.\n * @param then - The section that applies if the condition is true.\n * @param otherwise - (else) The section that applies if the condition is false.\n * @returns\n * @public\n */\nfunction $if(condition, then, otherwise) {\n return (extensions) => {\n const node = then(extensions);\n if (otherwise ||\n (isSchemaObject(node) && 'if' in node) ||\n isSlotCondition(node)) {\n const conditionalNode = {\n if: condition,\n then: node,\n };\n if (otherwise) {\n conditionalNode.else = otherwise(extensions);\n }\n return conditionalNode;\n }\n else if (isSlotCondition(node)) {\n Object.assign(node.else, { if: condition });\n }\n else if (isSchemaObject(node)) {\n Object.assign(node, { if: condition });\n }\n return node;\n };\n}\n/**\n * Applies a condition to a given schema section.\n * @param varName - The name of the variable that holds the current instance.\n * @param inName - The variable we are iterating over.\n * @param section - A section to repeat\n * @returns\n * @public\n */\nfunction $for(varName, inName, section) {\n return (extensions) => {\n const node = section(extensions);\n if (isSlotCondition(node)) {\n Object.assign(node.else, { for: [varName, inName] });\n }\n else if (isSchemaObject(node)) {\n Object.assign(node, { for: [varName, inName] });\n }\n return node;\n };\n}\n/**\n * Extends a schema node with a given set of extensions.\n * @param section - A section to apply an extension to.\n * @param extendWith - A partial schema snippet to apply to the section.\n * @returns\n * @public\n */\nfunction $extend(section, extendWith) {\n return (extensions) => {\n const node = section({});\n if (isSlotCondition(node)) {\n if (Array.isArray(node.else))\n return node;\n node.else = extendSchema(extendSchema(node.else, extendWith), extensions);\n return node;\n }\n return extendSchema(extendSchema(node, extendWith), extensions);\n };\n}\n/**\n * Creates a root schema section.\n * @param section - A section to make a root from.\n * @returns\n * @public\n */\nfunction $root(section) {\n return createRoot(section);\n}\n\n/**\n * Input definition for a button.\n * @public\n */\nconst button = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: outer(messages(message('$message.value')), wrapper(buttonInput(icon('prefix'), prefix(), buttonLabel('$label || $ui.submit.value'), suffix(), icon('suffix'))), help('$help')),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'input',\n /**\n * The family of inputs this one belongs too. For example \"text\" and \"email\"\n * are both part of the \"text\" family. This is primary used for styling.\n */\n family: 'button',\n /**\n * An array of extra props to accept for this input.\n */\n props: [],\n /**\n * Additional features that should be added to your input\n */\n features: [localize('submit'), ignore],\n};\n\n/**\n * Input definition for a checkbox(ess).\n * @public\n */\nconst checkbox = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: outer($if('$options == undefined', \n /**\n * Single checkbox structure.\n */\n boxWrapper(inner(prefix(), box(), decorator(icon('decorator')), suffix()), $extend(boxLabel('$label'), {\n if: '$label',\n })), \n /**\n * Multi checkbox structure.\n */\n fieldset(legend('$label'), help('$help'), boxOptions(boxOption(boxWrapper(inner(prefix(), $extend(box(), {\n bind: '$option.attrs',\n attrs: {\n id: '$option.attrs.id',\n value: '$option.value',\n checked: '$fns.isChecked($option.value)',\n },\n }), decorator(icon('decorator')), suffix()), $extend(boxLabel('$option.label'), {\n if: '$option.label',\n })), boxHelp('$option.help'))))), \n // Help text only goes under the input when it is a single.\n $if('$options == undefined && $help', help('$help')), messages(message('$message.value'))),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'input',\n /**\n * The family of inputs this one belongs too. For example \"text\" and \"email\"\n * are both part of the \"text\" family. This is primary used for styling.\n */\n family: 'box',\n /**\n * An array of extra props to accept for this input.\n */\n props: ['options', 'onValue', 'offValue', 'optionsLoader'],\n /**\n * Additional features that should be added to your input\n */\n features: [\n options,\n checkboxes,\n defaultIcon('decorator', 'checkboxDecorator'),\n ],\n};\n\n/**\n * Input definition for a file input.\n * @public\n */\nconst file = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: outer(wrapper(label('$label'), inner(icon('prefix', 'label'), prefix(), fileInput(), fileList(fileItem(icon('fileItem'), fileName('$file.name'), $if('$value.length === 1', fileRemove(icon('fileRemove'), '$ui.remove.value')))), $if('$value.length > 1', fileRemove('$ui.removeAll.value')), noFiles(icon('noFiles'), '$ui.noFiles.value'), suffix(), icon('suffix'))), help('$help'), messages(message('$message.value'))),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'input',\n /**\n * The family of inputs this one belongs too. For example \"text\" and \"email\"\n * are both part of the \"text\" family. This is primary used for styling.\n */\n family: 'text',\n /**\n * An array of extra props to accept for this input.\n */\n props: [],\n /**\n * Additional features that should be added to your input\n */\n features: [\n files,\n defaultIcon('fileItem', 'fileItem'),\n defaultIcon('fileRemove', 'fileRemove'),\n defaultIcon('noFiles', 'noFiles'),\n ],\n};\n\n/**\n * Input definition for a form.\n * @public\n */\nconst form = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: formInput('$slots.default', messages(message('$message.value')), actions(submitInput())),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'group',\n /**\n * An array of extra props to accept for this input.\n */\n props: [\n 'actions',\n 'submit',\n 'submitLabel',\n 'submitAttrs',\n 'submitBehavior',\n 'incompleteMessage',\n ],\n /**\n * Additional features that should be added to your input\n */\n features: [form$1, disables],\n};\n\n/**\n * Input definition for a group.\n * @public\n */\nconst group = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: fragment('$slots.default'),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'group',\n /**\n * An array of extra props to accept for this input.\n */\n props: [],\n /**\n * Additional features that should be added to your input\n */\n features: [disables],\n};\n\n/**\n * Input definition for a hidden input.\n * @public\n */\nconst hidden = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: $root(textInput()),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'input',\n /**\n * An array of extra props to accept for this input.\n */\n props: [],\n /**\n * Additional features that should be added to your input\n */\n features: [],\n};\n\n/**\n * Input definition for a list.\n * @public\n */\nconst list = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: fragment('$slots.default'),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'list',\n /**\n * An array of extra props to accept for this input.\n */\n props: [],\n /**\n * Additional features that should be added to your input\n */\n features: [disables],\n};\n\n/**\n * Input definition for a radio.\n * @public\n */\nconst radio = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: outer($if('$options == undefined', \n /**\n * Single radio structure.\n */\n boxWrapper(inner(prefix(), box(), decorator(icon('decorator')), suffix()), $if('$label', boxLabel('$label'))), \n /**\n * Multi radio structure.\n */\n fieldset(legend('$label'), help('$help'), boxOptions(boxOption(boxWrapper(inner(prefix(), $extend(box(), {\n bind: '$option.attrs',\n attrs: {\n id: '$option.attrs.id',\n value: '$option.value',\n checked: '$fns.isChecked($option.value)',\n },\n }), decorator(icon('decorator')), suffix()), $if('$option.label', boxLabel('$option.label'))), boxHelp('$option.help'))))), \n // Help text only goes under the input when it is a single.\n $if('$options === undefined && $help', help('$help')), messages(message('$message.value'))),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'input',\n /**\n * The family of inputs this one belongs too. For example \"text\" and \"email\"\n * are both part of the \"text\" family. This is primary used for styling.\n */\n family: 'box',\n /**\n * An array of extra props to accept for this input.\n */\n props: ['options', 'onValue', 'offValue', 'optionsLoader'],\n /**\n * Additional features that should be added to your input\n */\n features: [options, radios, defaultIcon('decorator', 'radioDecorator')],\n};\n\n/**\n * Input definition for a select.\n * @public\n */\nconst select = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: outer(wrapper(label('$label'), inner(icon('prefix'), prefix(), selectInput$1($if('$slots.default', () => '$slots.default', $if('$slots.option', optionSlot, option('$option.label')))), $if('$attrs.multiple !== undefined', () => '', icon('select')), suffix(), icon('suffix'))), help('$help'), messages(message('$message.value'))),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'input',\n /**\n * An array of extra props to accept for this input.\n */\n props: ['options', 'placeholder', 'optionsLoader'],\n /**\n * Additional features that should be added to your input\n */\n features: [options, select$1, defaultIcon('select', 'select')],\n};\n\n/**\n * Input definition for a textarea.\n * @public\n */\nconst textarea = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: outer(wrapper(label('$label'), inner(icon('prefix', 'label'), prefix(), textareaInput(), suffix(), icon('suffix'))), help('$help'), messages(message('$message.value'))),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'input',\n /**\n * An array of extra props to accept for this input.\n */\n props: [],\n /**\n * Additional features that should be added to your input\n */\n features: [initialValue],\n};\n\n/**\n * Input definition for a text.\n * @public\n */\nconst text = {\n /**\n * The actual schema of the input, or a function that returns the schema.\n */\n schema: outer(wrapper(label('$label'), inner(icon('prefix', 'label'), prefix(), textInput(), suffix(), icon('suffix'))), help('$help'), messages(message('$message.value'))),\n /**\n * The type of node, can be a list, group, or input.\n */\n type: 'input',\n /**\n * The family of inputs this one belongs too. For example \"text\" and \"email\"\n * are both part of the \"text\" family. This is primary used for styling.\n */\n family: 'text',\n /**\n * An array of extra props to accept for this input.\n */\n props: [],\n /**\n * Additional features that should be added to your input\n */\n features: [],\n};\n\nvar index = /*#__PURE__*/Object.freeze({\n __proto__: null,\n button: button,\n submit: button,\n checkbox: checkbox,\n file: file,\n form: form,\n group: group,\n hidden: hidden,\n list: list,\n radio: radio,\n select: select,\n textarea: textarea,\n text: text,\n color: text,\n date: text,\n datetimeLocal: text,\n email: text,\n month: text,\n number: text,\n password: text,\n search: text,\n tel: text,\n time: text,\n url: text,\n week: text,\n range: text\n});\n\nexport { $attrs, $extend, $for, $if, $root, actions, box, boxHelp, boxLabel, boxOption, boxOptions, boxWrapper, button, buttonInput, buttonLabel, checkbox, checkboxes, text as color, composable, createLibraryPlugin, createSection, text as date, text as datetimeLocal, decorator, defaultIcon, disables as disablesChildren, text as email, extendSchema, fieldset, file, fileInput, fileItem, fileList, fileName, fileRemove, files, form, formInput, form$1 as forms, fragment, group, help, hidden, icon, ignore as ignores, initialValue, inner, index as inputs, isSchemaObject, isSlotCondition, label, legend, list, localize, message, messages, text as month, noFiles, normalizeBoxes, normalizeOptions, text as number, option, optionSlot, options, outer, text as password, prefix, radio, radios, text as range, text as search, select, selectInput$1 as selectInput, select$1 as selects, button as submit, submitInput, suffix, text as tel, text, textInput, textarea, textareaInput, text as time, text as url, useSchema, text as week, wrapper };\n","import { has, regexForFormat, eq, empty } from '@formkit/utils';\n\n/**\n * Determine if the given input's value was should be considered \"accepted\".\n * @param context - The FormKitValidationContext\n * @public\n */\nconst accepted = function accepted({ value }) {\n return ['yes', 'on', '1', 1, true, 'true'].includes(value);\n};\naccepted.skipEmpty = false;\n\n/**\n * Determine if the given input's value is after a given date.\n * Defaults to current time.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst date_after = function ({ value }, compare = false) {\n const timestamp = Date.parse(compare || new Date());\n const fieldValue = Date.parse(String(value));\n return isNaN(fieldValue) ? false : fieldValue > timestamp;\n};\n\n/**\n * Determine if the given input's value is only alpha characters.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst alpha = function ({ value }, set = 'default') {\n const sets = {\n default: /^[a-zA-ZÀ-ÖØ-öø-ÿĄąĆćČčĎďĘęĚ죳ŃńŇňŘřŚśŠšŤťŮůŹźŻŽžż]+$/,\n latin: /^[a-zA-Z]+$/,\n };\n const selectedSet = has(sets, set) ? set : 'default';\n return sets[selectedSet].test(String(value));\n};\n\n/**\n * Determine if the given input's value is only alpha characters.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst alpha_spaces = function ({ value }, set = 'default') {\n const sets = {\n default: /^[a-zA-ZÀ-ÖØ-öø-ÿĄąĆćČčĎďĘęĚ죳ŃńŇňŘřŚśŠšŤťŮůŹźŻŽžż ]+$/,\n latin: /^[a-zA-Z ]+$/,\n };\n const selectedSet = has(sets, set) ? set : 'default';\n return sets[selectedSet].test(String(value));\n};\n\n/**\n * Determine if the given input's value is only alpha or numeric characters.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst alphanumeric = function ({ value }, set = 'default') {\n const sets = {\n default: /^[a-zA-Z0-9À-ÖØ-öø-ÿĄąĆćĘꣳŃńŚśŹźŻż]+$/,\n latin: /^[a-zA-Z0-9]+$/,\n };\n const selectedSet = has(sets, set) ? set : 'default';\n return sets[selectedSet].test(String(value));\n};\n\n/**\n * Determine if the given input's value before a given date.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst date_before = function ({ value }, compare = false) {\n const timestamp = Date.parse(compare || new Date());\n const fieldValue = Date.parse(String(value));\n return isNaN(fieldValue) ? false : fieldValue < timestamp;\n};\n\n/**\n * Determine if the given input's value is between two other values.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst between = function between({ value }, from, to) {\n if (!isNaN(value) && !isNaN(from) && !isNaN(to)) {\n const val = 1 * value;\n from = Number(from);\n to = Number(to);\n const [a, b] = from <= to ? [from, to] : [to, from];\n return val >= 1 * a && val <= 1 * b;\n }\n return false;\n};\n\nconst hasConfirm = /(_confirm(?:ed)?)$/;\n/**\n * Determine if the given input's value matches another input's value\n * @param context - The FormKitValidationContext\n * @public\n */\nconst confirm = function confirm(node, address, comparison = 'loose') {\n var _a;\n if (!address) {\n address = hasConfirm.test(node.name)\n ? node.name.replace(hasConfirm, '')\n : `${node.name}_confirm`;\n }\n const foreignValue = (_a = node.at(address)) === null || _a === void 0 ? void 0 : _a.value;\n return comparison === 'strict'\n ? node.value === foreignValue\n : node.value == foreignValue;\n};\n\n/**\n * Determine if the given input's value is between two other dates\n * @param context - The FormKitValidationContext\n * @public\n */\nconst date_between = function date_between({ value }, dateA, dateB) {\n dateA = dateA instanceof Date ? dateA.getTime() : Date.parse(dateA);\n dateB = dateB instanceof Date ? dateB.getTime() : Date.parse(dateB);\n const compareTo = value instanceof Date ? value.getTime() : Date.parse(String(value));\n if (dateA && !dateB) {\n dateB = dateA;\n dateA = Date.now();\n }\n else if (!dateA || !compareTo) {\n return false;\n }\n return compareTo >= dateA && compareTo <= dateB;\n};\n\n/**\n * Determine if the given input's value matches a specified date format\n * @param context - The FormKitValidationContext\n * @public\n */\nconst date_format = function date({ value }, format) {\n if (format && typeof format === 'string') {\n return regexForFormat(format).test(String(value));\n }\n return !isNaN(Date.parse(String(value)));\n};\n\n/**\n * Determine if the given input's value is a plausible email address.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst email = function email({ value }) {\n const isEmail = /^(([^<>()\\[\\]\\.,;:\\s@\\\"]+(\\.[^<>()\\[\\]\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@(([^<>()[\\]\\.,;:\\s@\\\"]+\\.)+[^<>()[\\]\\.,;:\\s@\\\"]{2,})$/i;\n return isEmail.test(String(value));\n};\n\n/**\n * Determine if the given input's value ends with a given string\n * @param context - The FormKitValidationContext\n * @public\n */\nconst ends_with = function ends_with({ value }, ...stack) {\n if (typeof value === 'string' && stack.length) {\n return stack.some((item) => {\n return value.endsWith(item);\n });\n }\n else if (typeof value === 'string' && stack.length === 0) {\n return true;\n }\n return false;\n};\n\n/**\n * Determine if the given input's value is in a set of possible values.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst is = function is({ value }, ...stack) {\n return stack.some((item) => {\n if (typeof item === 'object') {\n return eq(item, value);\n }\n return item == value;\n });\n};\n\n/**\n * Determine if the given input's value length is full width.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst length = function length({ value }, first = 0, second = Infinity) {\n first = parseInt(first);\n second = isNaN(parseInt(second)) ? Infinity : parseInt(second);\n const min = first <= second ? first : second;\n const max = second >= first ? second : first;\n if (typeof value === 'string' || Array.isArray(value)) {\n return value.length >= min && value.length <= max;\n }\n else if (value && typeof value === 'object') {\n const length = Object.keys(value).length;\n return length >= min && length <= max;\n }\n return false;\n};\n\n/**\n * Determine if the given input's value matches one or more values or regular expressions.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst matches = function matches({ value }, ...stack) {\n return stack.some((pattern) => {\n if (typeof pattern === 'string' &&\n pattern.substr(0, 1) === '/' &&\n pattern.substr(-1) === '/') {\n pattern = new RegExp(pattern.substr(1, pattern.length - 2));\n }\n if (pattern instanceof RegExp) {\n return pattern.test(String(value));\n }\n return pattern === value;\n });\n};\n\n/**\n * Determine if the given input's value is less than the maximum\n * @param context - The FormKitValidationContext\n * @public\n */\nconst max = function max({ value }, maximum = 10) {\n if (Array.isArray(value)) {\n return value.length <= maximum;\n }\n return Number(value) <= Number(maximum);\n};\n\n/**\n * Determine if the given input's value is less than a certain value.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst min = function min({ value }, minimum = 1) {\n if (Array.isArray(value)) {\n return value.length >= minimum;\n }\n return Number(value) >= Number(minimum);\n};\n\n/**\n * Determine if the given input's value is not in a given stack\n * @param context - The FormKitValidationContext\n * @public\n */\nconst not = function not({ value }, ...stack) {\n return !stack.some((item) => {\n if (typeof item === 'object') {\n return eq(item, value);\n }\n return item === value;\n });\n};\n\n/**\n * Determine if the given input's value is numeric\n * @param context - The FormKitValidationContext\n * @public\n */\nconst number = function number({ value }) {\n return !isNaN(value);\n};\n\n/**\n * Determine if the given input's value was required.\n * @param context - The FormKitValidationContext\n * @public\n */\nconst required = function required({ value }, action = 'default') {\n return action === 'trim' && typeof value === 'string'\n ? !empty(value.trim())\n : !empty(value);\n};\n/**\n * This rules should run even if the inputs is empty (obviously)\n */\nrequired.skipEmpty = false;\n\n/**\n * Determine if the given input's value starts with a substring\n * @param context - The FormKitValidationContext\n * @public\n */\nconst starts_with = function starts_with({ value }, ...stack) {\n if (typeof value === 'string' && stack.length) {\n return stack.some((item) => {\n return value.startsWith(item);\n });\n }\n else if (typeof value === 'string' && stack.length === 0) {\n return true;\n }\n return false;\n};\n\n/**\n * Determine if the given input's value is an http url\n * @param context - The FormKitValidationContext\n * @public\n */\nconst url = function url({ value }, ...stack) {\n try {\n const protocols = stack.length ? stack : ['http:', 'https:'];\n const url = new URL(String(value));\n return protocols.includes(url.protocol);\n }\n catch {\n return false;\n }\n};\n\nexport { accepted, alpha, alpha_spaces, alphanumeric, between, confirm, date_after, date_before, date_between, date_format, email, ends_with, is, length, matches, max, min, not, number, required, starts_with, url };\n","import { has } from '@formkit/utils';\nimport { isNode } from '@formkit/core';\n\n/**\n * A registry of all revoked observers.\n */\nconst revokedObservers = new WeakSet();\n/**\n * The FormKitNode to observe.\n * @param node - Any formkit node to observe.\n * @returns\n * @public\n */\nfunction createObserver(node, dependencies) {\n // The dependencies touched during tracking\n const deps = dependencies || Object.assign(new Map(), { active: false });\n // A registry of event receipts returned by the event system\n const receipts = new Map();\n /**\n * Simple function to add a dependency to the deps map.\n * @param event - The name of the event type (like commit/input etc)\n */\n const addDependency = function (event) {\n var _a;\n if (!deps.active)\n return;\n if (!deps.has(node))\n deps.set(node, new Set());\n (_a = deps.get(node)) === null || _a === void 0 ? void 0 : _a.add(event);\n };\n /**\n * Proxies the props of a node so we know which ones were messed with, could\n * potentially be more generalized in the future if we want to support\n * more sub-objects.\n * @param props - The props object from a node\n * @returns\n */\n const observeProps = function (props) {\n return new Proxy(props, {\n get(...args) {\n typeof args[1] === 'string' && addDependency(`prop:${args[1]}`);\n return Reflect.get(...args);\n },\n });\n };\n /**\n * Observes the FormKit ledger \"value\".\n * @param ledger - A formkit ledger counter.\n */\n const observeLedger = function (ledger) {\n return new Proxy(ledger, {\n get(...args) {\n if (args[1] === 'value') {\n return (key) => {\n addDependency(`count:${key}`);\n return ledger.value(key);\n };\n }\n return Reflect.get(...args);\n },\n });\n };\n /**\n * Return values from our observer proxy first pass through this function\n * which gives us a chance to listen sub-dependencies and properties.\n */\n const observe = function (value, property) {\n if (isNode(value)) {\n return createObserver(value, deps);\n }\n if (property === 'value')\n addDependency('commit');\n if (property === 'props')\n return observeProps(value);\n if (property === 'ledger')\n return observeLedger(value);\n return value;\n };\n /**\n * The actual proxy object of the original node.\n */\n const { proxy: observed, revoke, } = Proxy.revocable(node, {\n get(...args) {\n switch (args[1]) {\n case 'deps':\n return deps;\n case 'watch':\n return (block) => watch(observed, block);\n case 'observe':\n return () => {\n const old = new Map(deps);\n deps.clear();\n deps.active = true;\n return old;\n };\n case 'stopObserve':\n return () => {\n const newDeps = new Map(deps);\n deps.active = false;\n return newDeps;\n };\n case 'receipts':\n return receipts;\n case 'kill':\n return () => {\n removeListeners(receipts);\n revokedObservers.add(args[2]);\n revoke();\n };\n }\n const value = Reflect.get(...args);\n // If we're dealing with a function, we need to sub-call the function\n // get that return value, and pass it through the same logic.\n if (typeof value === 'function') {\n return (...subArgs) => {\n const subValue = value(...subArgs);\n return observe(subValue, args[1]);\n };\n }\n return observe(value, args[1]);\n },\n });\n return observed;\n}\n/**\n * Given two maps (toAdd and toRemove) apply the dependencies as event listeners\n * on the underlying nodes.\n * @param node - The node to apply dependencies to\n * @param delta - The toAdd and toRemove dependency Maps\n * @public\n */\nfunction applyListeners(node, [toAdd, toRemove], callback) {\n toAdd.forEach((events, depNode) => {\n events.forEach((event) => {\n node.receipts.has(depNode) || node.receipts.set(depNode, {});\n node.receipts.set(depNode, Object.assign(node.receipts.get(depNode), {\n [event]: depNode.on(event, callback),\n }));\n });\n });\n toRemove.forEach((events, depNode) => {\n events.forEach((event) => {\n if (node.receipts.has(depNode)) {\n const nodeReceipts = node.receipts.get(depNode);\n if (nodeReceipts && has(nodeReceipts, event)) {\n depNode.off(nodeReceipts[event]);\n delete nodeReceipts[event];\n node.receipts.set(depNode, nodeReceipts);\n }\n }\n });\n });\n}\n/**\n * Remove all the receipts from the observed node and subtree.\n * @param receipts - The formkit observer receipts to remove\n * @public\n */\nfunction removeListeners(receipts) {\n receipts.forEach((events, node) => {\n for (const event in events) {\n node.off(events[event]);\n }\n });\n}\n/**\n * Observes a chunk of code to dependencies, and then re-calls that chunk of\n * code when those dependencies are manipulated.\n * @param node - The node to observer\n * @param block - The block of code to observe\n * @public\n */\nasync function watch(node, block) {\n const oldDeps = new Map(node.deps);\n node.observe();\n const res = block(node);\n if (res instanceof Promise)\n await res;\n const newDeps = node.stopObserve();\n applyListeners(node, diffDeps(oldDeps, newDeps), () => watch(node, block));\n}\n/**\n * Determines which nodes should be added as dependencies and which should be\n * removed.\n * @param previous - The previous watcher dependencies\n * @param current - The new/current watcher dependencies\n * @returns\n * @public\n */\nfunction diffDeps(previous, current) {\n const toAdd = new Map();\n const toRemove = new Map();\n current.forEach((events, node) => {\n if (!previous.has(node)) {\n toAdd.set(node, events);\n }\n else {\n const eventsToAdd = new Set();\n const previousEvents = previous.get(node);\n events.forEach((event) => !(previousEvents === null || previousEvents === void 0 ? void 0 : previousEvents.has(event)) && eventsToAdd.add(event));\n toAdd.set(node, eventsToAdd);\n }\n });\n previous.forEach((events, node) => {\n if (!current.has(node)) {\n toRemove.set(node, events);\n }\n else {\n const eventsToRemove = new Set();\n const newEvents = current.get(node);\n events.forEach((event) => !(newEvents === null || newEvents === void 0 ? void 0 : newEvents.has(event)) && eventsToRemove.add(event));\n toRemove.set(node, eventsToRemove);\n }\n });\n return [toAdd, toRemove];\n}\n/**\n * Checks if the given noe is revoked.\n * @param node - Any observed node to check.\n * @returns\n * @public\n */\nfunction isKilled(node) {\n return revokedObservers.has(node);\n}\n\nexport { applyListeners, createObserver, diffDeps, isKilled, removeListeners };\n","import { createMessage } from '@formkit/core';\nimport { createObserver, removeListeners, isKilled, applyListeners, diffDeps } from '@formkit/observer';\nimport { cloneAny, token, eq, empty, clone, has } from '@formkit/utils';\n\n/**\n * Message that gets set when the node is awaiting validation.\n */\nconst validatingMessage = createMessage({\n type: 'state',\n blocking: true,\n visible: false,\n value: true,\n key: 'validating',\n});\n/**\n * The actual validation plugin function, everything must be bootstrapped here.\n * @param node - The node to bind validation to.\n * @public\n */\nfunction createValidationPlugin(baseRules = {}) {\n return function validationPlugin(node) {\n let availableRules = {\n ...baseRules,\n ...cloneAny(node.props.validationRules),\n };\n // create an observed node\n let observedNode = createObserver(node);\n const state = { input: token(), rerun: null, isPassing: true };\n let validation = cloneAny(node.props.validation);\n // If the node's validation props change, reboot:\n node.on('prop:validation', ({ payload }) => reboot(payload, availableRules));\n node.on('prop:validationRules', ({ payload }) => reboot(validation, payload));\n /**\n * Reboots the validation using new rules or declarations/intents.\n * @param newValidation - New validation declaration to use\n * @param newRules - New validation rules to use\n * @returns\n */\n function reboot(newValidation, newRules) {\n if (eq(availableRules, newRules) && eq(validation, newValidation))\n return;\n validation = cloneAny(newValidation);\n availableRules = { ...baseRules, ...cloneAny(node.props.validationRules) };\n // Destroy all observers that may re-trigger validation on an old stack\n removeListeners(observedNode.receipts);\n // Remove all existing messages before re-validating\n node.store.filter(() => false, 'validation');\n node.props.parsedRules = parseRules(newValidation, availableRules);\n observedNode.kill();\n observedNode = createObserver(node);\n validate(observedNode, node.props.parsedRules, state);\n }\n // Validate the field when this plugin is initialized\n node.props.parsedRules = parseRules(validation, availableRules);\n validate(observedNode, node.props.parsedRules, state);\n };\n}\n/**\n * Given parsed validations, a value and a node, run the validations and set\n * the appropriate store messages on the node.\n * @param value - The value being validated\n * @param node - The Node this value belongs to\n * @param rules - The rules\n */\nfunction validate(node, validations, state) {\n if (isKilled(node))\n return;\n state.input = token();\n state.isPassing = true;\n node.store.filter((message) => !message.meta.removeImmediately, 'validation');\n validations.forEach((validation) => validation.debounce && clearTimeout(validation.timer));\n if (validations.length) {\n node.store.set(validatingMessage);\n run(0, validations, node, state, false, () => {\n node.store.remove(validatingMessage.key);\n });\n }\n}\n/**\n * Runs validation rules recursively while collecting dependencies allowing for\n * cross-node validation rules that automatically re-trigger when a foreign\n * value is changed.\n * @param current - The index of the current validation rule\n * @param validations - The remaining validation rule stack to run\n * @param node - An observed node, the owner of this validation stack\n * @param state - An object of state information about this run\n * @param removeImmediately - Should messages created during this call be removed immediately when a new commit takes place?\n * @returns\n */\nfunction run(current, validations, node, state, removeImmediately, complete) {\n const validation = validations[current];\n if (!validation)\n return complete();\n const currentRun = state.input;\n validation.state = null;\n function next(async, result) {\n state.isPassing = state.isPassing && !!result;\n validation.queued = false;\n const newDeps = node.stopObserve();\n applyListeners(node, diffDeps(validation.deps, newDeps), () => {\n validation.queued = true;\n if (state.rerun)\n clearTimeout(state.rerun);\n state.rerun = setTimeout(validate, 0, node, validations, state);\n });\n validation.deps = newDeps;\n if (state.input === currentRun) {\n validation.state = result;\n if (result === false) {\n createFailedMessage(node, validation, removeImmediately || async);\n }\n else {\n removeMessage(node, validation);\n }\n if (validations.length > current + 1) {\n run(current + 1, validations, node, state, removeImmediately || async, complete);\n }\n else {\n // The validation has completed\n complete();\n }\n }\n }\n if ((!empty(node.value) || !validation.skipEmpty) &&\n (state.isPassing || validation.force)) {\n if (validation.queued) {\n runRule(validation, node, (result) => {\n result instanceof Promise\n ? result.then((r) => next(true, r))\n : next(false, result);\n });\n }\n else {\n // In this case our rule is not queued, so literally nothing happened that\n // would affect it, we just need to move past this rule and make no\n // modifications to state\n run(current + 1, validations, node, state, removeImmediately, complete);\n }\n }\n else {\n // This rule is not being run because either:\n // 1. The field is empty and this rule should not run when empty\n // 2. A previous validation rule is failing and this one is not forced\n // In this case we should call next validation.\n if (empty(node.value) && validation.skipEmpty && state.isPassing) {\n // This node has an empty value so its validation was skipped. So we\n // need to queue it up, we do that by starting an observation and just\n // touching the value attribute.\n node.observe();\n node.value;\n // Because this validation rule is skipped when the node's value is empty\n // so we keep the current value `state.isPassing` to the next rule execution\n // if we pass null it will be typecasted to false and all following rules\n // will be ignored including `required` rule which cause odds behavior\n next(false, state.isPassing);\n }\n else {\n next(false, null);\n }\n }\n}\n/**\n * Run a validation rule debounced or not.\n * @param validation - A validation to debounce\n */\nfunction runRule(validation, node, after) {\n if (validation.debounce) {\n validation.timer = setTimeout(() => {\n node.observe();\n after(validation.rule(node, ...validation.args));\n }, validation.debounce);\n }\n else {\n node.observe();\n after(validation.rule(node, ...validation.args));\n }\n}\n/**\n * The messages given to this function have already been set on the node, but\n * any other validation messages on the node that are not included in this\n * stack should be removed because they have been resolved.\n * @param node - The node to operate on.\n * @param messages - A new stack of messages\n */\nfunction removeMessage(node, validation) {\n const key = `rule_${validation.name}`;\n if (has(node.store, key)) {\n node.store.remove(key);\n }\n}\n/**\n *\n * @param value - The value that is failing\n * @param validation - The validation object\n */\nfunction createFailedMessage(node, validation, removeImmediately) {\n const i18nArgs = createI18nArgs(node, validation);\n const customMessage = createCustomMessage(node, validation, i18nArgs);\n // Here we short circuit the i18n system to force the output.\n const message = createMessage({\n blocking: validation.blocking,\n key: `rule_${validation.name}`,\n meta: {\n /**\n * Use this key instead of the message root key to produce i18n validation\n * messages.\n */\n messageKey: validation.name,\n /**\n * For messages that were created *by or after* a debounced or async\n * validation rule — we make note of it so we can immediately remove them\n * as soon as the next commit happens.\n */\n removeImmediately,\n /**\n * Determines if this message should be passed to localization.\n */\n localize: !customMessage,\n /**\n * The arguments that will be passed to the validation rules\n */\n i18nArgs,\n },\n type: 'validation',\n value: customMessage || 'This field is not valid.',\n });\n node.store.set(message);\n return message;\n}\n/**\n * Returns a custom validation message if applicable.\n * @param node - FormKit Node\n * @param validation - The validation rule being processed.\n */\nfunction createCustomMessage(node, validation, i18nArgs) {\n const customMessage = node.props.validationMessages &&\n has(node.props.validationMessages, validation.name)\n ? node.props.validationMessages[validation.name]\n : undefined;\n if (typeof customMessage === 'function') {\n return customMessage(...i18nArgs);\n }\n return customMessage;\n}\n/**\n * Creates the arguments passed to the i18n\n * @param node - The node that performed the validation\n * @param validation - The validation that failed\n */\nfunction createI18nArgs(node, validation) {\n // If a custom message has been found, short circuit the i18n system.\n return [\n {\n node,\n name: createMessageName(node),\n args: validation.args,\n },\n ];\n}\n/**\n * The name used in validation messages.\n * @param node - The node to display\n * @returns\n */\nfunction createMessageName(node) {\n if (typeof node.props.validationLabel === 'function') {\n return node.props.validationLabel(node);\n }\n return (node.props.validationLabel ||\n node.props.label ||\n node.props.name ||\n String(node.name));\n}\n/**\n * Describes hints, must also be changed in the debounceExtractor.\n */\nconst hintPattern = '(?:[\\\\*+?()0-9]+)';\n/**\n * A pattern to describe rule names. Rules names can only contain letters,\n * numbers, and underscores and must start with a letter.\n */\nconst rulePattern = '[a-zA-Z][a-zA-Z0-9_]+';\n/**\n * Regular expression for extracting rule data.\n */\nconst ruleExtractor = new RegExp(`^(${hintPattern}?${rulePattern})(?:\\\\:(.*)+)?$`, 'i');\n/**\n * Validation hints are special characters preceding a validation rule, like\n * !phone\n */\nconst hintExtractor = new RegExp(`^(${hintPattern})(${rulePattern})$`, 'i');\n/**\n * Given a hint string like ^(200)? or ^? or (200)?^ extract the hints to\n * matches.\n */\nconst debounceExtractor = /([\\*+?]+)?(\\(\\d+\\))([\\*+?]+)?/;\n/**\n * Determines if a given string is in the proper debounce format.\n */\nconst hasDebounce = /\\(\\d+\\)/;\n/**\n * The default values of the available validation hints.\n */\nconst defaultHints = {\n blocking: true,\n debounce: 0,\n force: false,\n skipEmpty: true,\n name: '',\n};\n/**\n * Parse validation intents and strings into validation rule stacks.\n * @param validation - Either a string a validation rules, or proper array of structured rules.\n * @internal\n */\nfunction parseRules(validation, rules) {\n if (!validation)\n return [];\n const intents = typeof validation === 'string'\n ? extractRules(validation)\n : clone(validation);\n return intents.reduce((validations, args) => {\n let rule = args.shift();\n const hints = {};\n if (typeof rule === 'string') {\n const [ruleName, parsedHints] = parseHints(rule);\n if (has(rules, ruleName)) {\n rule = rules[ruleName];\n Object.assign(hints, parsedHints);\n }\n }\n if (typeof rule === 'function') {\n validations.push({\n rule,\n args,\n timer: 0,\n state: null,\n queued: true,\n deps: new Map(),\n ...defaultHints,\n ...fnHints(hints, rule),\n });\n }\n return validations;\n }, []);\n}\n/**\n * A string of validation rules written in FormKitRule notation.\n * @param validation - The string of rules\n * @internal\n */\nfunction extractRules(validation) {\n return validation.split('|').reduce((rules, rule) => {\n const parsedRule = parseRule(rule);\n if (parsedRule) {\n rules.push(parsedRule);\n }\n return rules;\n }, []);\n}\n/**\n * Given a rule like confirm:password_confirm produce a FormKitValidationIntent\n * @param rule - A string representing a validation rule.\n * @returns\n */\nfunction parseRule(rule) {\n const trimmed = rule.trim();\n if (trimmed) {\n const matches = trimmed.match(ruleExtractor);\n if (matches && typeof matches[1] === 'string') {\n const ruleName = matches[1].trim();\n const args = matches[2] && typeof matches[2] === 'string'\n ? matches[2].split(',').map((s) => s.trim())\n : [];\n return [ruleName, ...args];\n }\n }\n return false;\n}\n/**\n * Given a rule name, detect if there are any additional hints like !\n * @param ruleName - string representing a rule name\n * @returns\n */\nfunction parseHints(ruleName) {\n const matches = ruleName.match(hintExtractor);\n if (!matches) {\n return [ruleName, { name: ruleName }];\n }\n const map = {\n '*': { force: true },\n '+': { skipEmpty: false },\n '?': { blocking: false },\n };\n const [, hints, rule] = matches;\n const hintGroups = hasDebounce.test(hints)\n ? hints.match(debounceExtractor) || []\n : [, hints];\n return [\n rule,\n [hintGroups[1], hintGroups[2], hintGroups[3]].reduce((hints, group) => {\n if (!group)\n return hints;\n if (hasDebounce.test(group)) {\n hints.debounce = parseInt(group.substr(1, group.length - 1));\n }\n else {\n group\n .split('')\n .forEach((hint) => has(map, hint) && Object.assign(hints, map[hint]));\n }\n return hints;\n }, { name: rule }),\n ];\n}\n/**\n * Extracts hint properties from the validation rule function itself and applies\n * them if they are not already in the set of validation hints extracted from\n * strings.\n * @param existingHints - An existing set of hints already parsed\n * @param rule - The actual rule function, which can contain hint properties\n * @returns\n */\nfunction fnHints(existingHints, rule) {\n if (!existingHints.name) {\n existingHints.name = rule.ruleName || rule.name;\n }\n return ['skipEmpty', 'force', 'debounce', 'blocking'].reduce((hints, hint) => {\n if (has(rule, hint) && !has(hints, hint)) {\n Object.assign(hints, {\n [hint]: rule[hint],\n });\n }\n return hints;\n }, existingHints);\n}\n/**\n * Extracts all validation messages from the given node and all its descendants.\n * This is not reactive and must be re called each time the messages change.\n * @param node - The FormKit node to extract validation rules from — as well as its descendants.\n * @public\n */\nfunction getValidationMessages(node) {\n const messages = new Map();\n const extract = (n) => {\n const nodeMessages = [];\n for (const key in n.store) {\n const message = n.store[key];\n if (message.type === 'validation' &&\n message.blocking &&\n message.visible &&\n typeof message.value === 'string') {\n nodeMessages.push(message);\n }\n }\n if (nodeMessages.length) {\n messages.set(n, nodeMessages);\n }\n return n;\n };\n extract(node).walk(extract);\n return messages;\n}\n\nexport { createValidationPlugin, getValidationMessages };\n","import { has } from '@formkit/utils';\n\n/**\n * Given a string, convert it to sentence case.\n * @param item - The string to sentence case\n * @returns\n * @public\n */\nfunction sentence(str) {\n return str[0].toUpperCase() + str.substr(1);\n}\n/**\n * Creates an oxford-comma separated list of items.\n * @param args - items to list out\n * @param conjunction - in: x, y, and z \"and\" is the conjunction to use\n * @returns\n * @public\n */\nfunction list(items, conjunction = 'or') {\n return items.reduce((oxford, item, index) => {\n oxford += item;\n if (index <= items.length - 2 && items.length > 2) {\n oxford += ', ';\n }\n if (index === items.length - 2) {\n oxford += `${items.length === 2 ? ' ' : ''}${conjunction} `;\n }\n return oxford;\n }, '');\n}\n/**\n * Given a string or a date return a nice human-readable version.\n * @param date - A string or a date.\n * @public\n */\nfunction date(date) {\n const dateTime = typeof date === 'string' ? new Date(Date.parse(date)) : date;\n if (!(dateTime instanceof Date)) {\n return '(unknown)';\n }\n return new Intl.DateTimeFormat(undefined, {\n dateStyle: 'medium',\n }).format(dateTime);\n}\n/**\n * Orders two variables smallest to largest.\n * @param first - first argument\n * @param second - Second argument\n * @returns\n * @public\n */\nfunction order(first, second) {\n return Number(first) >= Number(second) ? [second, first] : [first, second];\n}\n\n/**\n * Here we can import additional helper functions to assist in formatting our\n * language. Feel free to add additional helper methods to libs/formats if it\n * assists in creating good validation messages for your locale.\n */\n/**\n * Standard language for interface features.\n * @public\n */\nconst ui$B = {\n /**\n * Shown on buttons for adding new items.\n */\n add: 'إضافة',\n /**\n * Shown when a button to remove items is visible.\n */\n remove: 'إزالة',\n /**\n * Shown when there are multiple items to remove at the same time.\n */\n removeAll: 'إزالة الكل',\n /**\n * Shown when all fields are not filled out correctly.\n */\n incomplete: 'عذرا، لم يتم تعبئة جميع الحقول بشكل صحيح.',\n /**\n * Shown in a button inside a form to submit the form.\n */\n submit: 'إرسال',\n /**\n * Shown when no files are selected.\n */\n noFiles: 'لا يوجد ملف مختار',\n /**\n * Shown on buttons that move fields up in a list.\n */\n moveUp: 'تحرك لأعلى',\n /**\n * Shown on buttons that move fields down in a list.\n */\n moveDown: 'انتقل لأسفل',\n /**\n * Shown when something is actively loading.\n */\n isLoading: 'يتم الآن التحميل...',\n /**\n * Shown when there is more to load.\n */\n loadMore: 'تحميل المزيد',\n};\n/**\n * These are all the possible strings that pertain to validation messages.\n * @public\n */\nconst validation$B = {\n /**\n * The value is not an accepted value.\n * @see {@link https://docs.formkit.com/essentials/validation#accepted}\n */\n accepted({ name }) {\n /* \n\t\t