@sfxcode/formkit-primevue 0.5.0

package/dist/formkit-primevue.es.js

@@ -0,0 +1,3131 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import { defineComponent, getCurrentInstance, watch, watchEffect, reactive, h, ref, inject, computed, provide, toRef, onUnmounted, isRef, isReactive, toRaw, markRaw, createTextVNode, resolveComponent, openBlock, createElementBlock, normalizeClass, unref, createCommentVNode, createVNode, createBlock, Fragment, toDisplayString } from "vue";
+function token() {
+  return Math.random().toString(36).substring(2, 15);
+}
+function dedupe(arr1, arr2) {
+  const original = arr1 instanceof Set ? arr1 : new Set(arr1);
+  if (arr2)
+    arr2.forEach((item) => original.add(item));
+  return [...original];
+}
+function has(obj, property) {
+  return Object.prototype.hasOwnProperty.call(obj, property);
+}
+function eq(valA, valB, deep = true, explicit = ["__key"]) {
+  if (valA === valB)
+    return true;
+  if (typeof valB === "object" && typeof valA === "object") {
+    if (valA instanceof Map)
+      return false;
+    if (valA instanceof Set)
+      return false;
+    if (valA instanceof Date)
+      return false;
+    if (valA === null || valB === null)
+      return false;
+    if (Object.keys(valA).length !== Object.keys(valB).length)
+      return false;
+    for (const k of explicit) {
+      if ((k in valA || k in valB) && valA[k] !== valB[k])
+        return false;
+    }
+    for (const key in valA) {
+      if (!(key in valB))
+        return false;
+      if (valA[key] !== valB[key] && !deep)
+        return false;
+      if (deep && !eq(valA[key], valB[key], deep, explicit))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isRecord(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function isObject(o) {
+  return isRecord(o) || Array.isArray(o);
+}
+function isPojo(o) {
+  if (isRecord(o) === false)
+    return false;
+  if (o.__FKNode__ || o.__POJO__ === false)
+    return false;
+  const ctor = o.constructor;
+  if (ctor === void 0)
+    return true;
+  const prot = ctor.prototype;
+  if (isRecord(prot) === false)
+    return false;
+  if (prot.hasOwnProperty("isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
+}
+function extend(original, additional, extendArrays = false, ignoreUndefined = false) {
+  if (additional === null)
+    return null;
+  const merged = {};
+  if (typeof additional === "string")
+    return additional;
+  for (const key in original) {
+    if (has(additional, key) && (additional[key] !== void 0 || !ignoreUndefined)) {
+      if (extendArrays && Array.isArray(original[key]) && Array.isArray(additional[key])) {
+        merged[key] = original[key].concat(additional[key]);
+        continue;
+      }
+      if (additional[key] === void 0) {
+        continue;
+      }
+      if (isPojo(original[key]) && isPojo(additional[key])) {
+        merged[key] = extend(original[key], additional[key], extendArrays, ignoreUndefined);
+      } else {
+        merged[key] = additional[key];
+      }
+    } else {
+      merged[key] = original[key];
+    }
+  }
+  for (const key in additional) {
+    if (!has(merged, key) && additional[key] !== void 0) {
+      merged[key] = additional[key];
+    }
+  }
+  return merged;
+}
+function isQuotedString(str) {
+  if (str[0] !== '"' && str[0] !== "'")
+    return false;
+  if (str[0] !== str[str.length - 1])
+    return false;
+  const quoteType = str[0];
+  for (let p = 1; p < str.length; p++) {
+    if (str[p] === quoteType && (p === 1 || str[p - 1] !== "\\") && p !== str.length - 1) {
+      return false;
+    }
+  }
+  return true;
+}
+function rmEscapes(str) {
+  if (!str.length)
+    return "";
+  let clean = "";
+  let lastChar = "";
+  for (let p = 0; p < str.length; p++) {
+    const char = str.charAt(p);
+    if (char !== "\\" || lastChar === "\\") {
+      clean += char;
+    }
+    lastChar = char;
+  }
+  return clean;
+}
+function nodeProps(...sets) {
+  return sets.reduce((valid, props2) => {
+    const _a = props2, { value, name, modelValue, config, plugins } = _a, validProps = __objRest(_a, ["value", "name", "modelValue", "config", "plugins"]);
+    return Object.assign(valid, validProps);
+  }, {});
+}
+function parseArgs(str) {
+  const args = [];
+  let arg = "";
+  let depth = 0;
+  let quote = "";
+  let lastChar = "";
+  for (let p = 0; p < str.length; p++) {
+    const char = str.charAt(p);
+    if (char === quote && lastChar !== "\\") {
+      quote = "";
+    } else if ((char === "'" || char === '"') && !quote && lastChar !== "\\") {
+      quote = char;
+    } else if (char === "(" && !quote) {
+      depth++;
+    } else if (char === ")" && !quote) {
+      depth--;
+    }
+    if (char === "," && !quote && depth === 0) {
+      args.push(arg);
+      arg = "";
+    } else if (char !== " " || quote) {
+      arg += char;
+    }
+    lastChar = char;
+  }
+  if (arg) {
+    args.push(arg);
+  }
+  return args;
+}
+function except(obj, toRemove) {
+  const clean = {};
+  const exps = toRemove.filter((n) => n instanceof RegExp);
+  const keysToRemove = new Set(toRemove);
+  for (const key in obj) {
+    if (!keysToRemove.has(key) && !exps.some((exp) => exp.test(key))) {
+      clean[key] = obj[key];
+    }
+  }
+  return clean;
+}
+function only(obj, include) {
+  const clean = {};
+  const exps = include.filter((n) => n instanceof RegExp);
+  include.forEach((key) => {
+    if (!(key instanceof RegExp)) {
+      clean[key] = obj[key];
+    }
+  });
+  Object.keys(obj).forEach((key) => {
+    if (exps.some((exp) => exp.test(key))) {
+      clean[key] = obj[key];
+    }
+  });
+  return clean;
+}
+function camel(str) {
+  return str.replace(/-([a-z0-9])/gi, (_s, g) => g.toUpperCase());
+}
+function kebab(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, (_s, trail, cap) => trail + "-" + cap.toLowerCase()).replace(" ", "-").toLowerCase();
+}
+function clone(obj, explicit = ["__key", "__init"]) {
+  if (obj === null || obj instanceof RegExp || obj instanceof Date || obj instanceof Map || obj instanceof Set || typeof File === "function" && obj instanceof File)
+    return obj;
+  let returnObject;
+  if (Array.isArray(obj)) {
+    returnObject = obj.map((value) => {
+      if (typeof value === "object")
+        return clone(value, explicit);
+      return value;
+    });
+  } else {
+    returnObject = Object.keys(obj).reduce((newObj, key) => {
+      newObj[key] = typeof obj[key] === "object" ? clone(obj[key], explicit) : obj[key];
+      return newObj;
+    }, {});
+  }
+  for (const key of explicit) {
+    if (key in obj) {
+      Object.defineProperty(returnObject, key, {
+        enumerable: false,
+        value: obj[key]
+      });
+    }
+  }
+  return returnObject;
+}
+function cloneAny(obj) {
+  return typeof obj === "object" ? clone(obj) : obj;
+}
+function getAt(obj, addr) {
+  if (!obj || typeof obj !== "object")
+    return null;
+  const segments = addr.split(".");
+  let o = obj;
+  for (const i2 in segments) {
+    const segment = segments[i2];
+    if (has(o, segment)) {
+      o = o[segment];
+    }
+    if (+i2 === segments.length - 1)
+      return o;
+    if (!o || typeof o !== "object")
+      return null;
+  }
+  return null;
+}
+function undefine(value) {
+  return value !== void 0 && value !== "false" && value !== false ? true : void 0;
+}
+function init(obj) {
+  return !Object.isFrozen(obj) ? Object.defineProperty(obj, "__init", {
+    enumerable: false,
+    value: true
+  }) : obj;
+}
+function slugify(str) {
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]/g, " ").trim().replace(/\s+/g, "-");
+}
+function createDispatcher$1() {
+  const middleware = [];
+  let currentIndex = 0;
+  const use2 = (dispatchable) => middleware.push(dispatchable);
+  const dispatch = (payload) => {
+    const current = middleware[currentIndex];
+    if (typeof current === "function") {
+      return current(payload, (explicitPayload) => {
+        currentIndex++;
+        return dispatch(explicitPayload === void 0 ? payload : explicitPayload);
+      });
+    }
+    currentIndex = 0;
+    return payload;
+  };
+  use2.dispatch = dispatch;
+  use2.unshift = (dispatchable) => middleware.unshift(dispatchable);
+  use2.remove = (dispatchable) => {
+    const index = middleware.indexOf(dispatchable);
+    if (index > -1)
+      middleware.splice(index, 1);
+  };
+  return use2;
+}
+function createEmitter() {
+  const listeners = /* @__PURE__ */ new Map();
+  const receipts2 = /* @__PURE__ */ new Map();
+  let buffer = void 0;
+  const emitter = (node, event) => {
+    if (buffer) {
+      buffer.set(event.name, [node, event]);
+      return;
+    }
+    if (listeners.has(event.name)) {
+      listeners.get(event.name).forEach((wrapper) => {
+        if (event.origin === node || wrapper.modifiers.includes("deep")) {
+          wrapper.listener(event);
+        }
+      });
+    }
+    if (event.bubble) {
+      node.bubble(event);
+    }
+  };
+  emitter.on = (eventName, listener) => {
+    const [event, ...modifiers] = eventName.split(".");
+    const receipt = listener.receipt || token();
+    const wrapper = {
+      modifiers,
+      event,
+      listener,
+      receipt
+    };
+    listeners.has(event) ? listeners.get(event).push(wrapper) : listeners.set(event, [wrapper]);
+    receipts2.has(receipt) ? receipts2.get(receipt).push(event) : receipts2.set(receipt, [event]);
+    return receipt;
+  };
+  emitter.off = (receipt) => {
+    var _a;
+    if (receipts2.has(receipt)) {
+      (_a = receipts2.get(receipt)) === null || _a === void 0 ? void 0 : _a.forEach((event) => {
+        const eventListeners = listeners.get(event);
+        if (Array.isArray(eventListeners)) {
+          listeners.set(event, eventListeners.filter((wrapper) => wrapper.receipt !== receipt));
+        }
+      });
+      receipts2.delete(receipt);
+    }
+  };
+  emitter.pause = (node) => {
+    if (!buffer)
+      buffer = /* @__PURE__ */ new Map();
+    if (node) {
+      node.walk((child) => child._e.pause());
+    }
+  };
+  emitter.play = (node) => {
+    if (!buffer)
+      return;
+    const events = buffer;
+    buffer = void 0;
+    events.forEach(([node2, event]) => emitter(node2, event));
+    if (node) {
+      node.walk((child) => child._e.play());
+    }
+  };
+  return emitter;
+}
+function emit$1(node, context, name, payload, bubble2 = true) {
+  context._e(node, {
+    payload,
+    name,
+    bubble: bubble2,
+    origin: node
+  });
+  return node;
+}
+function bubble(node, _context, event) {
+  if (isNode(node.parent)) {
+    node.parent._e(node.parent, event);
+  }
+  return node;
+}
+function on(_node, context, name, listener) {
+  return context._e.on(name, listener);
+}
+function off(node, context, receipt) {
+  context._e.off(receipt);
+  return node;
+}
+const errorHandler = createDispatcher$1();
+errorHandler((error2, next) => {
+  if (!error2.message)
+    error2.message = String(`E${error2.code}`);
+  return next(error2);
+});
+const warningHandler = createDispatcher$1();
+warningHandler((warning, next) => {
+  if (!warning.message)
+    warning.message = String(`W${warning.code}`);
+  const result = next(warning);
+  if (console && typeof console.warn === "function")
+    console.warn(result.message);
+  return result;
+});
+function warn(code, data = {}) {
+  warningHandler.dispatch({ code, data });
+}
+function error(code, data = {}) {
+  throw Error(errorHandler.dispatch({ code, data }).message);
+}
+function createMessage(conf, node) {
+  const m = __spreadValues({
+    blocking: false,
+    key: token(),
+    meta: {},
+    type: "state",
+    visible: true
+  }, conf);
+  if (node && m.value && m.meta.localize !== false) {
+    m.value = node.t(m);
+    m.meta.locale = node.config.locale;
+  }
+  return m;
+}
+const storeTraps = {
+  apply: applyMessages,
+  set: setMessage,
+  remove: removeMessage,
+  filter: filterMessages,
+  reduce: reduceMessages,
+  release: releaseBuffer,
+  touch: touchMessages
+};
+function createStore(_buffer = false) {
+  const messages2 = {};
+  let node;
+  let buffer = _buffer;
+  let _b = [];
+  const _m = /* @__PURE__ */ new Map();
+  let _r = void 0;
+  const store = new Proxy(messages2, {
+    get(...args) {
+      const [_target, property] = args;
+      if (property === "buffer")
+        return buffer;
+      if (property === "_b")
+        return _b;
+      if (property === "_m")
+        return _m;
+      if (property === "_r")
+        return _r;
+      if (has(storeTraps, property)) {
+        return storeTraps[property].bind(null, messages2, store, node);
+      }
+      return Reflect.get(...args);
+    },
+    set(_t, prop, value) {
+      if (prop === "_n") {
+        node = value;
+        if (_r === "__n")
+          releaseMissed(node, store);
+        return true;
+      } else if (prop === "_b") {
+        _b = value;
+        return true;
+      } else if (prop === "buffer") {
+        buffer = value;
+        return true;
+      } else if (prop === "_r") {
+        _r = value;
+        return true;
+      }
+      error(101, node);
+      return false;
+    }
+  });
+  return store;
+}
+function setMessage(messageStore, store, node, message2) {
+  if (store.buffer) {
+    store._b.push([[message2]]);
+    return store;
+  }
+  if (messageStore[message2.key] !== message2) {
+    if (typeof message2.value === "string" && message2.meta.localize !== false) {
+      const previous = message2.value;
+      message2.value = node.t(message2);
+      if (message2.value !== previous) {
+        message2.meta.locale = node.props.locale;
+      }
+    }
+    const e = `message-${has(messageStore, message2.key) ? "updated" : "added"}`;
+    messageStore[message2.key] = Object.freeze(node.hook.message.dispatch(message2));
+    node.emit(e, message2);
+  }
+  return store;
+}
+function touchMessages(messageStore, store) {
+  for (const key in messageStore) {
+    const message2 = __spreadValues({}, messageStore[key]);
+    store.set(message2);
+  }
+}
+function removeMessage(messageStore, store, node, key) {
+  if (has(messageStore, key)) {
+    const message2 = messageStore[key];
+    delete messageStore[key];
+    node.emit("message-removed", message2);
+  }
+  if (store.buffer === true) {
+    store._b = store._b.filter((buffered) => {
+      buffered[0] = buffered[0].filter((m) => m.key !== key);
+      return buffered[1] || buffered[0].length;
+    });
+  }
+  return store;
+}
+function filterMessages(messageStore, store, node, callback, type) {
+  for (const key in messageStore) {
+    const message2 = messageStore[key];
+    if ((!type || message2.type === type) && !callback(message2)) {
+      removeMessage(messageStore, store, node, key);
+    }
+  }
+}
+function reduceMessages(messageStore, _store, _node, reducer, accumulator) {
+  for (const key in messageStore) {
+    const message2 = messageStore[key];
+    accumulator = reducer(accumulator, message2);
+  }
+  return accumulator;
+}
+function applyMessages(_messageStore, store, node, messages2, clear) {
+  if (Array.isArray(messages2)) {
+    if (store.buffer) {
+      store._b.push([messages2, clear]);
+      return;
+    }
+    const applied = new Set(messages2.map((message2) => {
+      store.set(message2);
+      return message2.key;
+    }));
+    if (typeof clear === "string") {
+      store.filter((message2) => message2.type !== clear || applied.has(message2.key));
+    } else if (typeof clear === "function") {
+      store.filter((message2) => !clear(message2) || applied.has(message2.key));
+    }
+  } else {
+    for (const address in messages2) {
+      const child = node.at(address);
+      if (child) {
+        child.store.apply(messages2[address], clear);
+      } else {
+        missed(node, store, address, messages2[address], clear);
+      }
+    }
+  }
+}
+function createMessages(node, ...errors2) {
+  const sourceKey = `${node.name}-set`;
+  const make = (error2) => createMessage({
+    key: slugify(error2),
+    type: "error",
+    value: error2,
+    meta: { source: sourceKey, autoClear: true }
+  });
+  return errors2.filter((m) => !!m).map((errorSet) => {
+    if (typeof errorSet === "string")
+      errorSet = [errorSet];
+    if (Array.isArray(errorSet)) {
+      return errorSet.map((error2) => make(error2));
+    } else {
+      const errors3 = {};
+      for (const key in errorSet) {
+        if (Array.isArray(errorSet[key])) {
+          errors3[key] = errorSet[key].map((error2) => make(error2));
+        } else {
+          errors3[key] = [make(errorSet[key])];
+        }
+      }
+      return errors3;
+    }
+  });
+}
+function missed(node, store, address, messages2, clear) {
+  var _a;
+  const misses = store._m;
+  if (!misses.has(address))
+    misses.set(address, []);
+  if (!store._r)
+    store._r = releaseMissed(node, store);
+  (_a = misses.get(address)) === null || _a === void 0 ? void 0 : _a.push([messages2, clear]);
+}
+function releaseMissed(node, store) {
+  return node.on("child.deep", ({ payload: child }) => {
+    store._m.forEach((misses, address) => {
+      if (node.at(address) === child) {
+        misses.forEach(([messages2, clear]) => {
+          child.store.apply(messages2, clear);
+        });
+        store._m.delete(address);
+      }
+    });
+    if (store._m.size === 0 && store._r) {
+      node.off(store._r);
+      store._r = void 0;
+    }
+  });
+}
+function releaseBuffer(_messageStore, store) {
+  store.buffer = false;
+  store._b.forEach(([messages2, clear]) => store.apply(messages2, clear));
+  store._b = [];
+}
+function createLedger() {
+  const ledger = {};
+  let n;
+  return {
+    count: (...args) => createCounter(n, ledger, ...args),
+    init(node) {
+      n = node;
+      node.on("message-added.deep", add(ledger, 1));
+      node.on("message-removed.deep", add(ledger, -1));
+    },
+    merge: (child) => merge(n, ledger, child),
+    settled(counterName) {
+      return has(ledger, counterName) ? ledger[counterName].promise : Promise.resolve();
+    },
+    unmerge: (child) => merge(n, ledger, child, true),
+    value(counterName) {
+      return has(ledger, counterName) ? ledger[counterName].count : 0;
+    }
+  };
+}
+function createCounter(node, ledger, counterName, condition, increment = 0) {
+  condition = parseCondition(condition || counterName);
+  if (!has(ledger, counterName)) {
+    const counter = {
+      condition,
+      count: 0,
+      name: counterName,
+      node,
+      promise: Promise.resolve(),
+      resolve: () => {
+      }
+    };
+    ledger[counterName] = counter;
+    increment = node.store.reduce((sum, m) => sum + counter.condition(m) * 1, increment);
+    node.each((child) => {
+      child.ledger.count(counter.name, counter.condition);
+      increment += child.ledger.value(counter.name);
+    });
+  }
+  return count(ledger[counterName], increment).promise;
+}
+function parseCondition(condition) {
+  if (typeof condition === "function") {
+    return condition;
+  }
+  return (m) => m.type === condition;
+}
+function count(counter, increment) {
+  const initial = counter.count;
+  const post = counter.count + increment;
+  counter.count = post;
+  if (initial === 0 && post !== 0) {
+    counter.node.emit(`unsettled:${counter.name}`, counter.count, false);
+    counter.promise = new Promise((r) => counter.resolve = r);
+  } else if (initial !== 0 && post === 0) {
+    counter.node.emit(`settled:${counter.name}`, counter.count, false);
+    counter.resolve();
+  }
+  counter.node.emit(`count:${counter.name}`, counter.count, false);
+  return counter;
+}
+function add(ledger, delta) {
+  return (e) => {
+    for (const name in ledger) {
+      const counter = ledger[name];
+      if (counter.condition(e.payload)) {
+        count(counter, delta);
+      }
+    }
+  };
+}
+function merge(parent, ledger, child, remove = false) {
+  for (const key in ledger) {
+    const condition = ledger[key].condition;
+    if (!remove)
+      child.ledger.count(key, condition);
+    const increment = child.ledger.value(key) * (remove ? -1 : 1);
+    if (!parent)
+      continue;
+    do {
+      parent.ledger.count(key, condition, increment);
+      parent = parent.parent;
+    } while (parent);
+  }
+}
+const registry = /* @__PURE__ */ new Map();
+const reflected = /* @__PURE__ */ new Map();
+const emit = createEmitter();
+const receipts = [];
+function register(node) {
+  if (node.props.id) {
+    registry.set(node.props.id, node);
+    reflected.set(node, node.props.id);
+    emit(node, {
+      payload: node,
+      name: node.props.id,
+      bubble: false,
+      origin: node
+    });
+  }
+}
+function deregister(node) {
+  if (reflected.has(node)) {
+    const id = reflected.get(node);
+    reflected.delete(node);
+    registry.delete(id);
+    emit(node, {
+      payload: null,
+      name: id,
+      bubble: false,
+      origin: node
+    });
+  }
+}
+function getNode$1(id) {
+  return registry.get(id);
+}
+function watchRegistry(id, callback) {
+  receipts.push(emit.on(id, callback));
+}
+function configChange(node, prop, value) {
+  let usingFallback = true;
+  !(prop in node.config._t) ? node.emit(`config:${prop}`, value, false) : usingFallback = false;
+  if (!(prop in node.props)) {
+    node.emit("prop", { prop, value });
+    node.emit(`prop:${prop}`, value);
+  }
+  return usingFallback;
+}
+function submitForm(id) {
+  const formElement = document.getElementById(id);
+  if (formElement instanceof HTMLFormElement) {
+    const event = new Event("submit", { cancelable: true, bubbles: true });
+    formElement.dispatchEvent(event);
+    return;
+  }
+  warn(151, id);
+}
+function clearState(node) {
+  const clear = (n) => {
+    for (const key in n.store) {
+      const message2 = n.store[key];
+      if (message2.type === "error" || message2.type === "ui" && key === "incomplete") {
+        n.store.remove(key);
+      } else if (message2.type === "state") {
+        n.store.set(__spreadProps(__spreadValues({}, message2), { value: false }));
+      }
+    }
+  };
+  clear(node);
+  node.walk(clear);
+}
+function reset(id, resetTo) {
+  const node = typeof id === "string" ? getNode$1(id) : id;
+  if (node) {
+    const initial = (n) => cloneAny(n.props.initial) || (n.type === "group" ? {} : n.type === "list" ? [] : void 0);
+    node._e.pause(node);
+    node.input(cloneAny(resetTo) || initial(node), false);
+    node.walk((child) => child.input(initial(child), false));
+    const finalInit = initial(node);
+    node.input(typeof finalInit === "object" ? cloneAny(resetTo) || init(finalInit) : finalInit, false);
+    node._e.play(node);
+    clearState(node);
+    node.emit("reset", node);
+    return node;
+  }
+  warn(152, id);
+  return;
+}
+const defaultConfig = {
+  delimiter: ".",
+  delay: 0,
+  locale: "en",
+  rootClasses: (key) => ({ [`formkit-${kebab(key)}`]: true })
+};
+const useIndex = Symbol("index");
+const valueRemoved = Symbol("removed");
+const valueMoved = Symbol("moved");
+const valueInserted = Symbol("inserted");
+function isList(arg) {
+  return arg.type === "list" && Array.isArray(arg._value);
+}
+function isNode(node) {
+  return node && typeof node === "object" && node.__FKNode__ === true;
+}
+const invalidSetter = (node, _context, property) => {
+  error(102, [node, property]);
+};
+const traps = {
+  _c: trap(getContext, invalidSetter, false),
+  add: trap(addChild),
+  addProps: trap(addProps),
+  address: trap(getAddress, invalidSetter, false),
+  at: trap(getNode),
+  bubble: trap(bubble),
+  clearErrors: trap(clearErrors$1),
+  calm: trap(calm),
+  config: trap(false),
+  define: trap(define),
+  disturb: trap(disturb),
+  destroy: trap(destroy),
+  hydrate: trap(hydrate),
+  index: trap(getIndex, setIndex, false),
+  input: trap(input),
+  each: trap(eachChild),
+  emit: trap(emit$1),
+  find: trap(find),
+  on: trap(on),
+  off: trap(off),
+  parent: trap(false, setParent),
+  plugins: trap(false),
+  remove: trap(removeChild),
+  root: trap(getRoot, invalidSetter, false),
+  reset: trap(resetValue),
+  resetConfig: trap(resetConfig),
+  setErrors: trap(setErrors$1),
+  submit: trap(submit),
+  t: trap(text),
+  use: trap(use),
+  name: trap(getName, false, false),
+  walk: trap(walkTree)
+};
+function createTraps() {
+  return new Map(Object.entries(traps));
+}
+function trap(getter, setter, curryGetter = true) {
+  return {
+    get: getter ? (node, context) => curryGetter ? (...args) => getter(node, context, ...args) : getter(node, context) : false,
+    set: setter !== void 0 ? setter : invalidSetter.bind(null)
+  };
+}
+function createHooks() {
+  const hooks = /* @__PURE__ */ new Map();
+  return new Proxy(hooks, {
+    get(_, property) {
+      if (!hooks.has(property)) {
+        hooks.set(property, createDispatcher$1());
+      }
+      return hooks.get(property);
+    }
+  });
+}
+let nameCount = 0;
+let idCount = 0;
+function createName(options) {
+  var _a, _b;
+  if (((_a = options.parent) === null || _a === void 0 ? void 0 : _a.type) === "list")
+    return useIndex;
+  return options.name || `${((_b = options.props) === null || _b === void 0 ? void 0 : _b.type) || "input"}_${++nameCount}`;
+}
+function createValue(options) {
+  if (options.type === "group") {
+    return init(options.value && typeof options.value === "object" && !Array.isArray(options.value) ? options.value : {});
+  } else if (options.type === "list") {
+    return init(Array.isArray(options.value) ? options.value : []);
+  }
+  return options.value === null ? "" : options.value;
+}
+function input(node, context, value, async = true) {
+  context._value = validateInput(node, node.hook.input.dispatch(value));
+  node.emit("input", context._value);
+  if (context.isSettled)
+    node.disturb();
+  if (async) {
+    if (context._tmo)
+      clearTimeout(context._tmo);
+    context._tmo = setTimeout(commit, node.props.delay, node, context);
+  } else {
+    commit(node, context);
+  }
+  return context.settled;
+}
+function validateInput(node, value) {
+  switch (node.type) {
+    case "input":
+      break;
+    case "group":
+      if (!value || typeof value !== "object")
+        error(107, [node, value]);
+      break;
+    case "list":
+      if (!Array.isArray(value))
+        error(108, [node, value]);
+      break;
+  }
+  return value;
+}
+function commit(node, context, calm2 = true, hydrate2 = true) {
+  context._value = context.value = node.hook.commit.dispatch(context._value);
+  if (node.type !== "input" && hydrate2)
+    node.hydrate();
+  node.emit("commit", context.value);
+  if (calm2)
+    node.calm();
+}
+function partial(context, { name, value, from }) {
+  if (Object.isFrozen(context._value))
+    return;
+  if (isList(context)) {
+    const insert = value === valueRemoved ? [] : value === valueMoved && typeof from === "number" ? context._value.splice(from, 1) : [value];
+    context._value.splice(name, value === valueMoved || from === valueInserted ? 0 : 1, ...insert);
+    return;
+  }
+  if (value !== valueRemoved) {
+    context._value[name] = value;
+  } else {
+    delete context._value[name];
+  }
+}
+function hydrate(node, context) {
+  const _value = context._value;
+  context.children.forEach((child) => {
+    if (typeof _value !== "object")
+      return;
+    if (child.name in _value) {
+      const childValue = child.type !== "input" || _value[child.name] && typeof _value[child.name] === "object" ? init(_value[child.name]) : _value[child.name];
+      child.input(childValue, false);
+    } else {
+      if (node.type !== "list" || typeof child.name === "number") {
+        partial(context, { name: child.name, value: child.value });
+      }
+      if (!_value.__init) {
+        if (child.type === "group")
+          child.input({}, false);
+        else if (child.type === "list")
+          child.input([], false);
+        else
+          child.input(void 0, false);
+      }
+    }
+  });
+  return node;
+}
+function disturb(node, context) {
+  var _a;
+  if (context._d <= 0) {
+    context.isSettled = false;
+    node.emit("settled", false, false);
+    context.settled = new Promise((resolve) => {
+      context._resolve = resolve;
+    });
+    if (node.parent)
+      (_a = node.parent) === null || _a === void 0 ? void 0 : _a.disturb();
+  }
+  context._d++;
+  return node;
+}
+function calm(node, context, value) {
+  var _a;
+  if (value !== void 0 && node.type !== "input") {
+    partial(context, value);
+    return commit(node, context, true, false);
+  }
+  if (context._d > 0)
+    context._d--;
+  if (context._d === 0) {
+    context.isSettled = true;
+    node.emit("settled", true, false);
+    if (node.parent)
+      (_a = node.parent) === null || _a === void 0 ? void 0 : _a.calm({ name: node.name, value: context.value });
+    if (context._resolve)
+      context._resolve(context.value);
+  }
+}
+function destroy(node, context) {
+  node.emit("destroying", node);
+  node.store.filter(() => false);
+  if (node.parent) {
+    node.parent.remove(node);
+  }
+  deregister(node);
+  context._value = context.value = void 0;
+  node.emit("destroyed", node);
+}
+function define(node, context, definition) {
+  context.type = definition.type;
+  context.props.definition = clone(definition);
+  context.value = context._value = createValue({
+    type: node.type,
+    value: context.value
+  });
+  if (definition.features) {
+    definition.features.forEach((feature) => feature(node));
+  }
+  if (definition.props) {
+    node.addProps(definition.props);
+  }
+  node.emit("defined", definition);
+}
+function addProps(node, context, props2) {
+  var _a;
+  if (node.props.attrs) {
+    const attrs = __spreadValues({}, node.props.attrs);
+    node.props._emit = false;
+    for (const attr in attrs) {
+      const camelName = camel(attr);
+      if (props2.includes(camelName)) {
+        node.props[camelName] = attrs[attr];
+        delete attrs[attr];
+      }
+    }
+    const initial = cloneAny(context._value);
+    node.props.initial = node.type !== "input" ? init(initial) : initial;
+    node.props._emit = true;
+    node.props.attrs = attrs;
+    if (node.props.definition) {
+      node.props.definition.props = [
+        ...((_a = node.props.definition) === null || _a === void 0 ? void 0 : _a.props) || [],
+        ...props2
+      ];
+    }
+  }
+  node.emit("added-props", props2);
+  return node;
+}
+function addChild(parent, parentContext, child, listIndex) {
+  if (parent.type === "input")
+    error(100, parent);
+  if (child.parent && child.parent !== parent) {
+    child.parent.remove(child);
+  }
+  if (!parentContext.children.includes(child)) {
+    if (listIndex !== void 0 && parent.type === "list") {
+      parentContext.children.splice(listIndex, 0, child);
+      if (Array.isArray(parent.value) && parent.value.length < parentContext.children.length) {
+        parent.disturb().calm({
+          name: listIndex,
+          value: child.value,
+          from: valueInserted
+        });
+      }
+    } else {
+      parentContext.children.push(child);
+    }
+    if (!child.isSettled)
+      parent.disturb();
+  }
+  if (child.parent !== parent) {
+    child.parent = parent;
+    if (child.parent !== parent) {
+      parent.remove(child);
+      child.parent.add(child);
+      return parent;
+    }
+  } else {
+    child.use(parent.plugins);
+  }
+  commit(parent, parentContext, false);
+  parent.ledger.merge(child);
+  parent.emit("child", child);
+  return parent;
+}
+function setParent(child, context, _property, parent) {
+  if (isNode(parent)) {
+    if (child.parent && child.parent !== parent) {
+      child.parent.remove(child);
+    }
+    context.parent = parent;
+    child.resetConfig();
+    !parent.children.includes(child) ? parent.add(child) : child.use(parent.plugins);
+    return true;
+  }
+  if (parent === null) {
+    context.parent = null;
+    return true;
+  }
+  return false;
+}
+function removeChild(node, context, child) {
+  const childIndex = context.children.indexOf(child);
+  if (childIndex !== -1) {
+    if (child.isSettled)
+      node.disturb();
+    context.children.splice(childIndex, 1);
+    let preserve = undefine(child.props.preserve);
+    let parent = child.parent;
+    while (preserve === void 0 && parent) {
+      preserve = undefine(parent.props.preserve);
+      parent = parent.parent;
+    }
+    if (!preserve) {
+      node.calm({
+        name: node.type === "list" ? childIndex : child.name,
+        value: valueRemoved
+      });
+    } else {
+      node.calm();
+    }
+    child.parent = null;
+    child.config._rmn = child;
+  }
+  node.ledger.unmerge(child);
+  return node;
+}
+function eachChild(_node, context, callback) {
+  context.children.forEach((child) => callback(child));
+}
+function walkTree(_node, context, callback, stopIfFalse = false) {
+  context.children.forEach((child) => {
+    if (callback(child) !== false || !stopIfFalse) {
+      child.walk(callback);
+    }
+  });
+}
+function resetConfig(node, context) {
+  const parent = node.parent || void 0;
+  context.config = createConfig(node.config._t, parent);
+  node.walk((n) => n.resetConfig());
+}
+function use(node, context, plugin, run = true, library = true) {
+  if (Array.isArray(plugin) || plugin instanceof Set) {
+    plugin.forEach((p) => use(node, context, p));
+    return node;
+  }
+  if (!context.plugins.has(plugin)) {
+    if (library && typeof plugin.library === "function")
+      plugin.library(node);
+    if (run && plugin(node) !== false) {
+      context.plugins.add(plugin);
+      node.children.forEach((child) => child.use(plugin));
+    }
+  }
+  return node;
+}
+function setIndex(node, _context, _property, setIndex2) {
+  if (isNode(node.parent)) {
+    const children = node.parent.children;
+    const index = setIndex2 >= children.length ? children.length - 1 : setIndex2 < 0 ? 0 : setIndex2;
+    const oldIndex = children.indexOf(node);
+    if (oldIndex === -1)
+      return false;
+    children.splice(oldIndex, 1);
+    children.splice(index, 0, node);
+    node.parent.children = children;
+    if (node.parent.type === "list")
+      node.parent.disturb().calm({ name: index, value: valueMoved, from: oldIndex });
+    return true;
+  }
+  return false;
+}
+function getIndex(node) {
+  if (node.parent) {
+    const index = [...node.parent.children].indexOf(node);
+    return index === -1 ? node.parent.children.length : index;
+  }
+  return -1;
+}
+function getContext(_node, context) {
+  return context;
+}
+function getName(node, context) {
+  var _a;
+  if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === "list")
+    return node.index;
+  return context.name !== useIndex ? context.name : node.index;
+}
+function getAddress(node, context) {
+  return context.parent ? context.parent.address.concat([node.name]) : [node.name];
+}
+function getNode(node, _context, locator) {
+  const address = typeof locator === "string" ? locator.split(node.config.delimiter) : locator;
+  if (!address.length)
+    return void 0;
+  const first = address[0];
+  let pointer = node.parent;
+  if (!pointer) {
+    if (String(address[0]) === String(node.name))
+      address.shift();
+    pointer = node;
+  }
+  if (first === "$parent")
+    address.shift();
+  while (pointer && address.length) {
+    const name = address.shift();
+    switch (name) {
+      case "$root":
+        pointer = node.root;
+        break;
+      case "$parent":
+        pointer = pointer.parent;
+        break;
+      case "$self":
+        pointer = node;
+        break;
+      default:
+        pointer = pointer.children.find((c) => String(c.name) === String(name)) || select(pointer, name);
+    }
+  }
+  return pointer || void 0;
+}
+function select(node, selector) {
+  const matches = String(selector).match(/^(find)\((.*)\)$/);
+  if (matches) {
+    const [, action, argStr] = matches;
+    const args = argStr.split(",").map((arg) => arg.trim());
+    switch (action) {
+      case "find":
+        return node.find(args[0], args[1]);
+      default:
+        return void 0;
+    }
+  }
+  return void 0;
+}
+function find(node, _context, searchTerm, searcher) {
+  return bfs(node, searchTerm, searcher);
+}
+function bfs(tree, searchValue, searchGoal = "name") {
+  const search = typeof searchGoal === "string" ? (n) => n[searchGoal] == searchValue : searchGoal;
+  const stack = [tree];
+  while (stack.length) {
+    const node = stack.shift();
+    if (search(node, searchValue))
+      return node;
+    stack.push(...node.children);
+  }
+  return void 0;
+}
+function getRoot(n) {
+  let node = n;
+  while (node.parent) {
+    node = node.parent;
+  }
+  return node;
+}
+function createConfig(target = {}, parent) {
+  let node = void 0;
+  return new Proxy(target, {
+    get(...args) {
+      const prop = args[1];
+      if (prop === "_t")
+        return target;
+      const localValue = Reflect.get(...args);
+      if (localValue !== void 0)
+        return localValue;
+      if (parent) {
+        const parentVal = parent.config[prop];
+        if (parentVal !== void 0)
+          return parentVal;
+      }
+      if (target.rootConfig && typeof prop === "string") {
+        const rootValue = target.rootConfig[prop];
+        if (rootValue !== void 0)
+          return rootValue;
+      }
+      if (prop === "delay" && (node === null || node === void 0 ? void 0 : node.type) === "input")
+        return 20;
+      return defaultConfig[prop];
+    },
+    set(...args) {
+      const prop = args[1];
+      const value = args[2];
+      if (prop === "_n") {
+        node = value;
+        if (target.rootConfig)
+          target.rootConfig._add(node);
+        return true;
+      }
+      if (prop === "_rmn") {
+        if (target.rootConfig)
+          target.rootConfig._rm(node);
+        node = void 0;
+        return true;
+      }
+      if (!eq(target[prop], value, false)) {
+        const didSet = Reflect.set(...args);
+        if (node) {
+          node.emit(`config:${prop}`, value, false);
+          configChange(node, prop, value);
+          node.walk((n) => configChange(n, prop, value), true);
+        }
+        return didSet;
+      }
+      return true;
+    }
+  });
+}
+function text(node, _context, key, type = "ui") {
+  const fragment = typeof key === "string" ? { key, value: key, type } : key;
+  const value = node.hook.text.dispatch(fragment);
+  node.emit("text", value, false);
+  return value.value;
+}
+function submit(node) {
+  const name = node.name;
+  do {
+    if (node.props.isForm === true)
+      break;
+    if (!node.parent)
+      error(106, name);
+    node = node.parent;
+  } while (node);
+  if (node.props.id) {
+    submitForm(node.props.id);
+  }
+}
+function resetValue(node, _context, value) {
+  return reset(node, value);
+}
+function setErrors$1(node, _context, localErrors, childErrors) {
+  const sourceKey = `${node.name}-set`;
+  createMessages(node, localErrors, childErrors).forEach((errors2) => {
+    node.store.apply(errors2, (message2) => message2.meta.source === sourceKey);
+  });
+  return node;
+}
+function clearErrors$1(node, context, clearChildErrors = true) {
+  setErrors$1(node, context, []);
+  if (clearChildErrors) {
+    const sourceKey = `${node.name}-set`;
+    node.walk((child) => {
+      child.store.filter((message2) => {
+        return !(message2.type === "error" && message2.meta && message2.meta.source === sourceKey);
+      });
+    });
+  }
+  return node;
+}
+function defaultProps(node) {
+  if (!has(node.props, "id"))
+    node.props.id = `input_${idCount++}`;
+  return node;
+}
+function createProps(initial) {
+  const props2 = {
+    initial: typeof initial === "object" ? cloneAny(initial) : initial
+  };
+  let node;
+  let isEmitting = true;
+  return new Proxy(props2, {
+    get(...args) {
+      const [_t, prop] = args;
+      if (has(props2, prop))
+        return Reflect.get(...args);
+      if (node && typeof prop === "string" && node.config[prop] !== void 0)
+        return node.config[prop];
+      return void 0;
+    },
+    set(target, property, originalValue, receiver) {
+      if (property === "_n") {
+        node = originalValue;
+        return true;
+      }
+      if (property === "_emit") {
+        isEmitting = originalValue;
+        return true;
+      }
+      const { prop, value } = node.hook.prop.dispatch({
+        prop: property,
+        value: originalValue
+      });
+      if (!eq(props2[prop], value, false) || typeof value === "object") {
+        const didSet = Reflect.set(target, prop, value, receiver);
+        if (isEmitting) {
+          node.emit("prop", { prop, value });
+          if (typeof prop === "string")
+            node.emit(`prop:${prop}`, value);
+        }
+        return didSet;
+      }
+      return true;
+    }
+  });
+}
+function findDefinition(node, plugins) {
+  if (node.props.definition)
+    return node.define(node.props.definition);
+  for (const plugin of plugins) {
+    if (node.props.definition)
+      return;
+    if (typeof plugin.library === "function") {
+      plugin.library(node);
+    }
+  }
+}
+function createContext(options) {
+  const value = createValue(options);
+  const config = createConfig(options.config || {}, options.parent);
+  return {
+    _d: 0,
+    _e: createEmitter(),
+    _resolve: false,
+    _tmo: false,
+    _value: value,
+    children: dedupe(options.children || []),
+    config,
+    hook: createHooks(),
+    isCreated: false,
+    isSettled: true,
+    ledger: createLedger(),
+    name: createName(options),
+    parent: options.parent || null,
+    plugins: /* @__PURE__ */ new Set(),
+    props: createProps(value),
+    settled: Promise.resolve(value),
+    store: createStore(true),
+    traps: createTraps(),
+    type: options.type || "input",
+    value
+  };
+}
+function nodeInit(node, options) {
+  var _a;
+  node.ledger.init(node.store._n = node.props._n = node.config._n = node);
+  node.props._emit = false;
+  if (options.props)
+    Object.assign(node.props, options.props);
+  node.props._emit = true;
+  findDefinition(node, /* @__PURE__ */ new Set([
+    ...options.plugins || [],
+    ...node.parent ? node.parent.plugins : []
+  ]));
+  if (options.plugins) {
+    for (const plugin of options.plugins) {
+      use(node, node._c, plugin, true, false);
+    }
+  }
+  defaultProps(node);
+  node.each((child) => node.add(child));
+  if (node.parent)
+    node.parent.add(node, options.index);
+  if (node.type === "input" && node.children.length)
+    error(100, node);
+  input(node, node._c, node._value, false);
+  node.store.release();
+  if ((_a = options.props) === null || _a === void 0 ? void 0 : _a.id)
+    register(node);
+  node.emit("created", node);
+  node.isCreated = true;
+  return node;
+}
+function createNode(options) {
+  const ops = options || {};
+  const context = createContext(ops);
+  const node = new Proxy(context, {
+    get(...args) {
+      const [, property] = args;
+      if (property === "__FKNode__")
+        return true;
+      const trap2 = context.traps.get(property);
+      if (trap2 && trap2.get)
+        return trap2.get(node, context);
+      return Reflect.get(...args);
+    },
+    set(...args) {
+      const [, property, value] = args;
+      const trap2 = context.traps.get(property);
+      if (trap2 && trap2.set)
+        return trap2.set(node, context, property, value);
+      return Reflect.set(...args);
+    }
+  });
+  return nodeInit(node, ops);
+}
+function isDOM(node) {
+  return typeof node !== "string" && has(node, "$el");
+}
+function isComponent$1(node) {
+  return typeof node !== "string" && has(node, "$cmp");
+}
+function isConditional(node) {
+  if (!node || typeof node === "string")
+    return false;
+  return has(node, "if") && has(node, "then");
+}
+function isSugar(node) {
+  return typeof node !== "string" && "$formkit" in node;
+}
+function sugar(node) {
+  if (typeof node === "string") {
+    return {
+      $el: "text",
+      children: node
+    };
+  }
+  if (isSugar(node)) {
+    const _a = node, { $formkit: type, for: iterator, if: condition, children, key, bind } = _a, props2 = __objRest(_a, ["$formkit", "for", "if", "children", "key", "bind"]);
+    return Object.assign({
+      $cmp: "FormKit",
+      props: __spreadProps(__spreadValues({}, props2), { type })
+    }, condition ? { if: condition } : {}, iterator ? { for: iterator } : {}, children ? { children } : {}, key ? { key } : {}, bind ? { bind } : {});
+  }
+  return node;
+}
+function compile(expr) {
+  let provideTokens;
+  const requirements = /* @__PURE__ */ new Set();
+  const x = function expand(operand, tokens) {
+    return typeof operand === "function" ? operand(tokens) : operand;
+  };
+  const operatorRegistry = [
+    {
+      "&&": (l, r, t) => x(l, t) && x(r, t),
+      "||": (l, r, t) => x(l, t) || x(r, t)
+    },
+    {
+      "===": (l, r, t) => !!(x(l, t) === x(r, t)),
+      "!==": (l, r, t) => !!(x(l, t) !== x(r, t)),
+      "==": (l, r, t) => !!(x(l, t) == x(r, t)),
+      "!=": (l, r, t) => !!(x(l, t) != x(r, t)),
+      ">=": (l, r, t) => !!(x(l, t) >= x(r, t)),
+      "<=": (l, r, t) => !!(x(l, t) <= x(r, t)),
+      ">": (l, r, t) => !!(x(l, t) > x(r, t)),
+      "<": (l, r, t) => !!(x(l, t) < x(r, t))
+    },
+    {
+      "+": (l, r, t) => x(l, t) + x(r, t),
+      "-": (l, r, t) => x(l, t) - x(r, t)
+    },
+    {
+      "*": (l, r, t) => x(l, t) * x(r, t),
+      "/": (l, r, t) => x(l, t) / x(r, t),
+      "%": (l, r, t) => x(l, t) % x(r, t)
+    }
+  ];
+  const operatorSymbols = operatorRegistry.reduce((s, g) => {
+    return s.concat(Object.keys(g));
+  }, []);
+  const operatorChars = new Set(operatorSymbols.map((key) => key.charAt(0)));
+  function getOp(symbols, char, p, expression) {
+    const candidates = symbols.filter((s) => s.startsWith(char));
+    if (!candidates.length)
+      return false;
+    return candidates.find((symbol) => {
+      if (expression.length >= p + symbol.length) {
+        const nextChars = expression.substring(p, p + symbol.length);
+        if (nextChars === symbol)
+          return symbol;
+      }
+      return false;
+    });
+  }
+  function getStep(p, expression, direction = 1) {
+    let next = direction ? expression.substring(p + 1).trim() : expression.substring(0, p).trim();
+    if (!next.length)
+      return -1;
+    if (!direction) {
+      const reversed = next.split("").reverse();
+      const start = reversed.findIndex((char2) => operatorChars.has(char2));
+      next = reversed.slice(start).join("");
+    }
+    const char = next[0];
+    return operatorRegistry.findIndex((operators) => {
+      const symbols = Object.keys(operators);
+      return !!getOp(symbols, char, 0, next);
+    });
+  }
+  function getTail(pos, expression) {
+    let tail = "";
+    const length = expression.length;
+    let depth = 0;
+    for (let p = pos; p < length; p++) {
+      const char = expression.charAt(p);
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth--;
+      } else if (depth === 0 && char === " ") {
+        continue;
+      }
+      if (depth === 0 && getOp(operatorSymbols, char, p, expression)) {
+        return [tail, p - 1];
+      } else {
+        tail += char;
+      }
+    }
+    return [tail, expression.length - 1];
+  }
+  function parseLogicals(expression, step = 0) {
+    const operators = operatorRegistry[step];
+    const length = expression.length;
+    const symbols = Object.keys(operators);
+    let depth = 0;
+    let quote = false;
+    let op = null;
+    let operand = "";
+    let left = null;
+    let operation;
+    let lastChar = "";
+    let char = "";
+    let parenthetical = "";
+    let parenQuote = "";
+    let startP = 0;
+    const addTo = (depth2, char2) => {
+      depth2 ? parenthetical += char2 : operand += char2;
+    };
+    for (let p = 0; p < length; p++) {
+      lastChar = char;
+      char = expression.charAt(p);
+      if ((char === "'" || char === '"') && lastChar !== "\\" && (depth === 0 && !quote || depth && !parenQuote)) {
+        if (depth) {
+          parenQuote = char;
+        } else {
+          quote = char;
+        }
+        addTo(depth, char);
+        continue;
+      } else if (quote && (char !== quote || lastChar === "\\") || parenQuote && (char !== parenQuote || lastChar === "\\")) {
+        addTo(depth, char);
+        continue;
+      } else if (quote === char) {
+        quote = false;
+        addTo(depth, char);
+        continue;
+      } else if (parenQuote === char) {
+        parenQuote = false;
+        addTo(depth, char);
+        continue;
+      } else if (char === " ") {
+        continue;
+      } else if (char === "(") {
+        if (depth === 0) {
+          startP = p;
+        } else {
+          parenthetical += char;
+        }
+        depth++;
+      } else if (char === ")") {
+        depth--;
+        if (depth === 0) {
+          const fn = typeof operand === "string" && operand.startsWith("$") ? operand : void 0;
+          const hasTail = fn && expression.charAt(p + 1) === ".";
+          let tail = "";
+          if (hasTail) {
+            [tail, p] = getTail(p + 2, expression);
+          }
+          const lStep = op ? step : getStep(startP, expression, 0);
+          const rStep = getStep(p, expression);
+          if (lStep === -1 && rStep === -1) {
+            operand = evaluate(parenthetical, -1, fn, tail);
+          } else if (op && (lStep >= rStep || rStep === -1) && step === lStep) {
+            left = op.bind(null, evaluate(parenthetical, -1, fn, tail));
+            op = null;
+            operand = "";
+          } else if (rStep > lStep && step === rStep) {
+            operand = evaluate(parenthetical, -1, fn, tail);
+          } else {
+            operand += `(${parenthetical})${hasTail ? `.${tail}` : ""}`;
+          }
+          parenthetical = "";
+        } else {
+          parenthetical += char;
+        }
+      } else if (depth === 0 && (operation = getOp(symbols, char, p, expression))) {
+        if (p === 0) {
+          error(103, [operation, expression]);
+        }
+        p += operation.length - 1;
+        if (p === expression.length - 1) {
+          error(104, [operation, expression]);
+        }
+        if (!op) {
+          if (left) {
+            op = operators[operation].bind(null, evaluate(left, step));
+            left = null;
+          } else {
+            op = operators[operation].bind(null, evaluate(operand, step));
+            operand = "";
+          }
+        } else if (operand) {
+          left = op.bind(null, evaluate(operand, step));
+          op = operators[operation].bind(null, left);
+          operand = "";
+        }
+        continue;
+      } else {
+        addTo(depth, char);
+      }
+    }
+    if (operand && op) {
+      op = op.bind(null, evaluate(operand, step));
+    }
+    op = !op && left ? left : op;
+    if (!op && operand) {
+      op = (v, t) => {
+        return typeof v === "function" ? v(t) : v;
+      };
+      op = op.bind(null, evaluate(operand, step));
+    }
+    if (!op && !operand) {
+      error(105, expression);
+    }
+    return op;
+  }
+  function evaluate(operand, step, fnToken, tail) {
+    if (fnToken) {
+      const fn = evaluate(fnToken, operatorRegistry.length);
+      let userFuncReturn;
+      let tailCall = tail ? compile(`$${tail}`) : false;
+      if (typeof fn === "function") {
+        const args = parseArgs(String(operand)).map((arg) => evaluate(arg, -1));
+        return (tokens) => {
+          const userFunc = fn(tokens);
+          if (typeof userFunc !== "function") {
+            warn(150, fnToken);
+            return userFunc;
+          }
+          userFuncReturn = userFunc(...args.map((arg) => typeof arg === "function" ? arg(tokens) : arg));
+          if (tailCall) {
+            tailCall = tailCall.provide((subTokens) => {
+              const rootTokens = provideTokens(subTokens);
+              const t = subTokens.reduce((tokenSet, token2) => {
+                const isTail = token2 === tail || (tail === null || tail === void 0 ? void 0 : tail.startsWith(`${token2}(`));
+                if (isTail) {
+                  const value = getAt(userFuncReturn, token2);
+                  tokenSet[token2] = () => value;
+                } else {
+                  tokenSet[token2] = rootTokens[token2];
+                }
+                return tokenSet;
+              }, {});
+              return t;
+            });
+          }
+          return tailCall ? tailCall() : userFuncReturn;
+        };
+      }
+    } else if (typeof operand === "string") {
+      if (operand === "true")
+        return true;
+      if (operand === "false")
+        return false;
+      if (operand === "undefined")
+        return void 0;
+      if (isQuotedString(operand))
+        return rmEscapes(operand.substring(1, operand.length - 1));
+      if (!isNaN(+operand))
+        return Number(operand);
+      if (step < operatorRegistry.length - 1) {
+        return parseLogicals(operand, step + 1);
+      } else {
+        if (operand.startsWith("$")) {
+          const cleaned = operand.substring(1);
+          requirements.add(cleaned);
+          return function getToken(tokens) {
+            return cleaned in tokens ? tokens[cleaned]() : void 0;
+          };
+        }
+        return operand;
+      }
+    }
+    return operand;
+  }
+  const compiled = parseLogicals(expr.startsWith("$:") ? expr.substring(2) : expr);
+  const reqs = Array.from(requirements);
+  function provide2(callback) {
+    provideTokens = callback;
+    return Object.assign(compiled.bind(null, callback(reqs)), {
+      provide: provide2
+    });
+  }
+  return Object.assign(compiled, {
+    provide: provide2
+  });
+}
+const outer = composable("outer", () => ({
+  $el: "div",
+  attrs: {
+    class: "$classes.outer",
+    "data-type": "$type",
+    "data-multiple": "$attrs.multiple",
+    "data-disabled": "$disabled || undefined",
+    "data-complete": "$state.complete || undefined",
+    "data-invalid": "$state.valid === false && $state.validationVisible || undefined",
+    "data-errors": "$state.errors || undefined",
+    "data-submitted": "$state.submitted || undefined"
+  }
+}));
+const wrapper$2 = composable("wrapper", () => ({
+  $el: "div",
+  attrs: {
+    class: "$classes.wrapper"
+  }
+}));
+const inner = composable("inner", () => ({
+  $el: "div",
+  attrs: {
+    class: "$classes.inner"
+  }
+}));
+const help = (schema = {}, children = [], target = "help", cond = "$help") => ({
+  if: `$slots.${target}`,
+  then: `$slots.${target}`,
+  else: extend({
+    $el: "div",
+    attrs: {
+      id: `$: "help-" + ${target == "optionHelp" ? "$option.attrs.id" : "$id"}`,
+      class: `$classes.${target}`
+    },
+    if: cond,
+    children
+  }, schema)
+});
+const messages = composable("messages", () => ({
+  $el: "ul",
+  if: "$fns.length($messages)",
+  attrs: {
+    class: "$classes.messages",
+    "aria-live": '$type === "form" && "assertive" || "polite"'
+  }
+}));
+const message = composable("message", () => ({
+  $el: "li",
+  for: ["message", "$messages"],
+  attrs: {
+    key: "$message.key",
+    class: "$classes.message",
+    id: `$id + '-' + $message.key`,
+    "data-message-type": "$message.type"
+  }
+}));
+const prefix = composable("prefix", () => ({ $el: null }));
+const suffix = composable("suffix", () => ({ $el: null }));
+function isSchemaObject(schema) {
+  return typeof schema === "object" && ("$el" in schema || "$cmp" in schema || "$formkit" in schema);
+}
+function extendSchema(schema, extension = {}) {
+  if (typeof schema === "string") {
+    return isSchemaObject(extension) || typeof extension === "string" ? extension : schema;
+  } else if (Array.isArray(schema)) {
+    return isSchemaObject(extension) ? extension : schema;
+  }
+  return extend(schema, extension);
+}
+function composable(key, schema) {
+  return (extendWith = {}, children = void 0) => {
+    const root = typeof schema === "function" ? schema(children) : typeof schema === "object" ? clone(schema) : schema;
+    const isObj = isSchemaObject(root);
+    if (isObj && !("children" in root) && children) {
+      if (Array.isArray(children)) {
+        if (children.length) {
+          root.children = children;
+        }
+      } else {
+        root.children = [children];
+      }
+    }
+    const extended = extendSchema(root, extendWith);
+    return {
+      if: `$slots.${key}`,
+      then: `$slots.${key}`,
+      else: Array.isArray(extended) ? extended : [extended]
+    };
+  };
+}
+function useSchema(inputSchema) {
+  return (extensions = {}) => {
+    const input2 = composable("input", inputSchema)(extensions.input);
+    return [
+      outer(extensions.outer, [
+        wrapper$2(extensions.wrapper, [
+          label(extensions.label, "$label"),
+          inner(extensions.inner, [
+            prefix(extensions.prefix),
+            ...Array.isArray(input2) ? input2 : [input2],
+            suffix(extensions.suffix)
+          ])
+        ]),
+        help(extensions.help, "$help"),
+        messages(extensions.messages, [
+          message(extensions.message, "$message.value")
+        ])
+      ])
+    ];
+  };
+}
+const label = composable("label", () => ({
+  $el: "label",
+  if: "$label",
+  attrs: {
+    for: "$id",
+    class: "$classes.label"
+  }
+}));
+createMessage({
+  type: "state",
+  blocking: true,
+  visible: false,
+  value: true,
+  key: "validating"
+});
+let registered = false;
+const errors = {
+  100: ({ data: node }) => `Only groups, lists, and forms can have children (${node.name}).`,
+  101: ({ data: node }) => `You cannot directly modify the store (${node.name}). See: https://formkit.com/advanced/core#message-store`,
+  102: ({ data: [node, property] }) => `You cannot directly assign node.${property} (${node.name})`,
+  103: ({ data: [operator] }) => `Schema expressions cannot start with an operator (${operator})`,
+  104: ({ data: [operator, expression] }) => `Schema expressions cannot end with an operator (${operator} in "${expression}")`,
+  105: ({ data: expression }) => `Invalid schema expression: ${expression}`,
+  106: ({ data: name }) => `Cannot submit because (${name}) is not in a form.`,
+  107: ({ data: [node, value] }) => `Cannot set ${node.name} to non object value: ${value}`,
+  108: ({ data: [node, value] }) => `Cannot set ${node.name} to non array value: ${value}`,
+  600: ({ data: node }) => `Unknown input type${typeof node.props.type === "string" ? ' "' + node.props.type + '"' : ""} ("${node.name}")`,
+  601: ({ data: node }) => `Input definition${typeof node.props.type === "string" ? ' "' + node.props.type + '"' : ""} is missing a schema or component property (${node.name}).`
+};
+const warnings = {
+  150: ({ data: fn }) => `Schema function "${fn}()" is not a valid function.`,
+  151: ({ data: id }) => `No form element with id: ${id}`,
+  152: ({ data: id }) => `No input element with id: ${id}`,
+  350: ({ data: node }) => `Invalid options prop for radio input (${node.name}). See https://formkit.com/inputs/radio`,
+  650: 'Schema "$get()" must use the id of an input to access.',
+  651: ({ data: id }) => `Cannot setErrors() on "${id}" because no such id exists.`,
+  652: ({ data: id }) => `Cannot clearErrors() on "${id}" because no such id exists.`
+};
+const decodeErrors = (error2, next) => {
+  if (error2.code in errors) {
+    const err = errors[error2.code];
+    error2.message = typeof err === "function" ? err(error2) : err;
+  }
+  return next(error2);
+};
+if (!registered)
+  errorHandler(decodeErrors);
+const decodeWarnings = (warning, next) => {
+  if (warning.code in warnings) {
+    const warn2 = warnings[warning.code];
+    warning.message = typeof warn2 === "function" ? warn2(warning) : warn2;
+  }
+  return next(warning);
+};
+if (!registered)
+  warningHandler(decodeWarnings);
+registered = true;
+const memo = {};
+let instanceKey;
+const instanceScopes = /* @__PURE__ */ new Map();
+const raw = "__raw__";
+const isClassProp = /[a-zA-Z0-9\-][cC]lass$/;
+function getRef(token2, data) {
+  const value = ref(null);
+  if (token2 === "get") {
+    const nodeRefs = {};
+    value.value = get$1.bind(null, nodeRefs);
+    return value;
+  }
+  const path = token2.split(".");
+  watchEffect(() => value.value = getValue(data, path));
+  return value;
+}
+function getValue(set, path) {
+  if (Array.isArray(set)) {
+    for (const subset of set) {
+      const value = subset !== false && getValue(subset, path);
+      if (value !== void 0)
+        return value;
+    }
+    return void 0;
+  }
+  let foundValue = void 0;
+  path.reduce((obj, segment, i2, arr) => {
+    if (typeof obj !== "object") {
+      foundValue = void 0;
+      return arr.splice(1);
+    }
+    const currentValue = obj[segment];
+    if (i2 === path.length - 1 && currentValue !== void 0) {
+      foundValue = currentValue;
+    }
+    return obj[segment];
+  }, set);
+  return foundValue;
+}
+function get$1(nodeRefs, id) {
+  if (typeof id !== "string")
+    return warn(650);
+  if (!(id in nodeRefs))
+    nodeRefs[id] = ref(void 0);
+  if (nodeRefs[id].value === void 0) {
+    nodeRefs[id].value = null;
+    const root = getNode$1(id);
+    if (root)
+      nodeRefs[id].value = root.context;
+    watchRegistry(id, ({ payload: node }) => {
+      nodeRefs[id].value = isNode(node) ? node.context : node;
+    });
+  }
+  return nodeRefs[id].value;
+}
+function parseSchema(library, schema) {
+  function parseCondition2(library2, node) {
+    const condition = provider(compile(node.if), { if: true });
+    const children = createElements(library2, node.then);
+    const alternate = node.else ? createElements(library2, node.else) : null;
+    return [condition, children, alternate];
+  }
+  function parseConditionAttr(attr, _default) {
+    var _a, _b;
+    const condition = provider(compile(attr.if));
+    let b = () => _default;
+    let a = () => _default;
+    if (typeof attr.then === "object") {
+      a = parseAttrs(attr.then, void 0);
+    } else if (typeof attr.then === "string" && ((_a = attr.then) === null || _a === void 0 ? void 0 : _a.startsWith("$"))) {
+      a = provider(compile(attr.then));
+    } else {
+      a = () => attr.then;
+    }
+    if (has(attr, "else")) {
+      if (typeof attr.else === "object") {
+        b = parseAttrs(attr.else);
+      } else if (typeof attr.else === "string" && ((_b = attr.else) === null || _b === void 0 ? void 0 : _b.startsWith("$"))) {
+        b = provider(compile(attr.else));
+      } else {
+        b = () => attr.else;
+      }
+    }
+    return () => condition() ? a() : b();
+  }
+  function parseAttrs(unparsedAttrs, bindExp, _default = {}) {
+    const explicitAttrs = new Set(Object.keys(unparsedAttrs || {}));
+    const boundAttrs = bindExp ? provider(compile(bindExp)) : () => ({});
+    const setters = [
+      (attrs) => {
+        const bound = boundAttrs();
+        for (const attr in bound) {
+          if (!explicitAttrs.has(attr)) {
+            attrs[attr] = bound[attr];
+          }
+        }
+      }
+    ];
+    if (unparsedAttrs) {
+      if (isConditional(unparsedAttrs)) {
+        const condition = parseConditionAttr(unparsedAttrs, _default);
+        return condition;
+      }
+      for (let attr in unparsedAttrs) {
+        const value = unparsedAttrs[attr];
+        let getValue2;
+        const isStr = typeof value === "string";
+        if (attr.startsWith(raw)) {
+          attr = attr.substring(7);
+          getValue2 = () => value;
+        } else if (isStr && value.startsWith("$") && value.length > 1 && !(value.startsWith("$reset") && isClassProp.test(attr))) {
+          getValue2 = provider(compile(value));
+        } else if (typeof value === "object" && isConditional(value)) {
+          getValue2 = parseConditionAttr(value, void 0);
+        } else if (typeof value === "object" && isPojo(value)) {
+          getValue2 = parseAttrs(value);
+        } else {
+          getValue2 = () => value;
+        }
+        setters.push((attrs) => {
+          attrs[attr] = getValue2();
+        });
+      }
+    }
+    return () => {
+      const attrs = {};
+      setters.forEach((setter) => setter(attrs));
+      return attrs;
+    };
+  }
+  function parseNode(library2, _node) {
+    let element = null;
+    let attrs = () => null;
+    let condition = false;
+    let children = null;
+    let alternate = null;
+    let iterator = null;
+    let resolve = false;
+    const node = sugar(_node);
+    if (isDOM(node)) {
+      element = node.$el;
+      attrs = node.$el !== "text" ? parseAttrs(node.attrs, node.bind) : () => null;
+    } else if (isComponent$1(node)) {
+      if (typeof node.$cmp === "string") {
+        if (has(library2, node.$cmp)) {
+          element = library2[node.$cmp];
+        } else {
+          element = node.$cmp;
+          resolve = true;
+        }
+      } else {
+        element = node.$cmp;
+      }
+      attrs = parseAttrs(node.props, node.bind);
+    } else if (isConditional(node)) {
+      [condition, children, alternate] = parseCondition2(library2, node);
+    }
+    if (!isConditional(node) && "if" in node) {
+      condition = provider(compile(node.if));
+    } else if (!isConditional(node) && element === null) {
+      condition = () => true;
+    }
+    if ("children" in node && node.children) {
+      if (typeof node.children === "string") {
+        if (node.children.startsWith("$slots.")) {
+          element = element === "text" ? "slot" : element;
+          children = provider(compile(node.children));
+        } else if (node.children.startsWith("$") && node.children.length > 1) {
+          const value = provider(compile(node.children));
+          children = () => String(value());
+        } else {
+          children = () => String(node.children);
+        }
+      } else if (Array.isArray(node.children)) {
+        children = createElements(library2, node.children);
+      } else {
+        const [childCondition, c, a] = parseCondition2(library2, node.children);
+        children = (iterationData) => childCondition && childCondition() ? c && c(iterationData) : a && a(iterationData);
+      }
+    }
+    if (isComponent$1(node)) {
+      if (children) {
+        const produceChildren = children;
+        children = (iterationData) => {
+          return {
+            default(slotData2, key) {
+              var _a, _b, _c, _d;
+              const currentKey = instanceKey;
+              if (key)
+                instanceKey = key;
+              if (slotData2)
+                (_a = instanceScopes.get(instanceKey)) === null || _a === void 0 ? void 0 : _a.unshift(slotData2);
+              if (iterationData)
+                (_b = instanceScopes.get(instanceKey)) === null || _b === void 0 ? void 0 : _b.unshift(iterationData);
+              const c = produceChildren(iterationData);
+              if (slotData2)
+                (_c = instanceScopes.get(instanceKey)) === null || _c === void 0 ? void 0 : _c.shift();
+              if (iterationData)
+                (_d = instanceScopes.get(instanceKey)) === null || _d === void 0 ? void 0 : _d.shift();
+              instanceKey = currentKey;
+              return c;
+            }
+          };
+        };
+        children.slot = true;
+      } else {
+        children = () => ({});
+      }
+    }
+    if ("for" in node && node.for) {
+      const values = node.for.length === 3 ? node.for[2] : node.for[1];
+      const getValues = typeof values === "string" && values.startsWith("$") ? provider(compile(values)) : () => values;
+      iterator = [
+        getValues,
+        node.for[0],
+        node.for.length === 3 ? String(node.for[1]) : null
+      ];
+    }
+    return [condition, element, attrs, children, alternate, iterator, resolve];
+  }
+  function createSlots(children, iterationData) {
+    const slots = children(iterationData);
+    const currentKey = instanceKey;
+    return Object.keys(slots).reduce((allSlots, slotName) => {
+      const slotFn = slots && slots[slotName];
+      allSlots[slotName] = (data) => {
+        return slotFn && slotFn(data, currentKey) || null;
+      };
+      return allSlots;
+    }, {});
+  }
+  function createElement(library2, node) {
+    const [condition, element, attrs, children, alternate, iterator, resolve] = parseNode(library2, node);
+    let createNodes = (iterationData) => {
+      if (condition && element === null && children) {
+        return condition() ? children(iterationData) : alternate && alternate(iterationData);
+      }
+      if (element && (!condition || condition())) {
+        if (element === "text" && children) {
+          return createTextVNode(String(children()));
+        }
+        if (element === "slot" && children)
+          return children(iterationData);
+        const el = resolve ? resolveComponent(element) : element;
+        const slots = (children === null || children === void 0 ? void 0 : children.slot) ? createSlots(children, iterationData) : null;
+        return h(el, attrs(), slots || (children ? children(iterationData) : []));
+      }
+      return typeof alternate === "function" ? alternate(iterationData) : alternate;
+    };
+    if (iterator) {
+      const repeatedNode = createNodes;
+      const [getValues, valueName, keyName] = iterator;
+      createNodes = () => {
+        const _v = getValues();
+        const values = !isNaN(_v) ? Array(Number(_v)).fill(0).map((_, i2) => i2) : _v;
+        const fragment = [];
+        if (typeof values !== "object")
+          return null;
+        const instanceScope = instanceScopes.get(instanceKey) || [];
+        for (const key in values) {
+          const iterationData = Object.defineProperty(__spreadValues(__spreadProps(__spreadValues({}, instanceScope.reduce((previousIterationData, scopedData) => {
+            if (previousIterationData.__idata) {
+              return __spreadValues(__spreadValues({}, previousIterationData), scopedData);
+            }
+            return scopedData;
+          }, {})), {
+            [valueName]: values[key]
+          }), keyName !== null ? { [keyName]: key } : {}), "__idata", { enumerable: false, value: true });
+          instanceScope.unshift(iterationData);
+          fragment.push(repeatedNode.bind(null, iterationData)());
+          instanceScope.shift();
+        }
+        return fragment;
+      };
+    }
+    return createNodes;
+  }
+  function createElements(library2, schema2) {
+    if (Array.isArray(schema2)) {
+      const els = schema2.map(createElement.bind(null, library2));
+      return (iterationData) => els.map((element2) => element2(iterationData));
+    }
+    const element = createElement(library2, schema2);
+    return (iterationData) => element(iterationData);
+  }
+  const providers = [];
+  function provider(compiled, hints = {}) {
+    const compiledFns = {};
+    providers.push((callback, key) => {
+      compiledFns[key] = compiled.provide((tokens) => callback(tokens, hints));
+    });
+    return () => compiledFns[instanceKey]();
+  }
+  return function createInstance(providerCallback, key) {
+    const memoKey = JSON.stringify(schema);
+    const [render, compiledProviders] = has(memo, memoKey) ? memo[memoKey] : [createElements(library, schema), providers];
+    memo[memoKey] = [render, compiledProviders];
+    compiledProviders.forEach((compiledProvider) => {
+      compiledProvider(providerCallback, key);
+    });
+    return () => {
+      instanceKey = key;
+      return render();
+    };
+  };
+}
+function useScope(token2, defaultValue) {
+  const scopedData = instanceScopes.get(instanceKey) || [];
+  let scopedValue = void 0;
+  if (scopedData.length) {
+    scopedValue = getValue(scopedData, token2.split("."));
+  }
+  return scopedValue === void 0 ? defaultValue : scopedValue;
+}
+function slotData(data, key) {
+  return new Proxy(data, {
+    get(...args) {
+      let data2 = void 0;
+      const property = args[1];
+      if (typeof property === "string") {
+        const prevKey = instanceKey;
+        instanceKey = key;
+        data2 = useScope(property, void 0);
+        instanceKey = prevKey;
+      }
+      return data2 !== void 0 ? data2 : Reflect.get(...args);
+    }
+  });
+}
+function createRenderFn(instanceCreator, data, instanceKey2) {
+  return instanceCreator((requirements, hints = {}) => {
+    return requirements.reduce((tokens, token2) => {
+      if (token2.startsWith("slots.")) {
+        const slot = token2.substring(6);
+        const hasSlot = data.slots && has(data.slots, slot);
+        if (hints.if) {
+          tokens[token2] = () => hasSlot;
+        } else if (data.slots && hasSlot) {
+          const scopedData = slotData(data, instanceKey2);
+          tokens[token2] = () => data.slots[slot](scopedData);
+          return tokens;
+        }
+      }
+      const value = getRef(token2, data);
+      tokens[token2] = () => useScope(token2, value.value);
+      return tokens;
+    }, {});
+  }, instanceKey2);
+}
+let i = 0;
+const FormKitSchema = defineComponent({
+  name: "FormKitSchema",
+  props: {
+    schema: {
+      type: [Array, Object],
+      required: true
+    },
+    data: {
+      type: Object,
+      default: () => ({})
+    },
+    library: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(props2, context) {
+    const instance = getCurrentInstance();
+    let instanceKey2 = Symbol(String(i++));
+    instanceScopes.set(instanceKey2, []);
+    let provider = parseSchema(props2.library, props2.schema);
+    let render;
+    let data;
+    watch(() => props2.schema, (newSchema, oldSchema) => {
+      var _a;
+      instanceKey2 = Symbol(String(i++));
+      provider = parseSchema(props2.library, props2.schema);
+      render = createRenderFn(provider, data, instanceKey2);
+      if (newSchema === oldSchema) {
+        ((_a = instance === null || instance === void 0 ? void 0 : instance.proxy) === null || _a === void 0 ? void 0 : _a.$forceUpdate)();
+      }
+    }, { deep: true });
+    watchEffect(() => {
+      data = Object.assign(reactive(props2.data), {
+        slots: context.slots
+      });
+      render = createRenderFn(provider, data, instanceKey2);
+    });
+    return () => render();
+  }
+});
+const nativeProps = {
+  config: {
+    type: Object,
+    default: {}
+  },
+  classes: {
+    type: Object,
+    required: false
+  },
+  delay: {
+    type: Number,
+    required: false
+  },
+  errors: {
+    type: Array,
+    default: []
+  },
+  inputErrors: {
+    type: Object,
+    default: () => ({})
+  },
+  index: {
+    type: Number,
+    required: false
+  },
+  id: {
+    type: String,
+    required: false
+  },
+  modelValue: {
+    required: false
+  },
+  name: {
+    type: String,
+    required: false
+  },
+  parent: {
+    type: Object,
+    required: false
+  },
+  plugins: {
+    type: Array,
+    default: []
+  },
+  sectionsSchema: {
+    type: Object,
+    default: {}
+  },
+  type: {
+    type: [String, Object],
+    default: "text"
+  },
+  validation: {
+    type: [String, Array],
+    required: false
+  },
+  validationMessages: {
+    type: Object,
+    required: false
+  },
+  validationRules: {
+    type: Object,
+    required: false
+  },
+  validationLabel: {
+    type: [String, Function],
+    required: false
+  }
+};
+const props = nativeProps;
+const parentSymbol = Symbol("FormKitParent");
+defineComponent({
+  props,
+  emits: {
+    input: (_value, _node) => true,
+    inputRaw: (_value, _node) => true,
+    "update:modelValue": (_value) => true,
+    node: (node) => !!node,
+    submit: (_data, _node) => true,
+    submitRaw: (_event, _node) => true
+  },
+  inheritAttrs: false,
+  setup(props2, context) {
+    const node = useInput(props2, context);
+    if (!node.props.definition)
+      error(600, node);
+    if (node.props.definition.component) {
+      return () => {
+        var _a;
+        return h((_a = node.props.definition) === null || _a === void 0 ? void 0 : _a.component, {
+          context: node.context
+        }, __spreadValues({}, context.slots));
+      };
+    }
+    const schema = ref([]);
+    const generateSchema = () => {
+      var _a, _b;
+      const schemaDefinition = (_b = (_a = node.props) === null || _a === void 0 ? void 0 : _a.definition) === null || _b === void 0 ? void 0 : _b.schema;
+      if (!schemaDefinition)
+        error(601, node);
+      schema.value = typeof schemaDefinition === "function" ? schemaDefinition(__spreadValues({}, props2.sectionsSchema)) : schemaDefinition;
+    };
+    generateSchema();
+    node.on("schema", generateSchema);
+    context.emit("node", node);
+    const library = node.props.definition.library;
+    context.expose({ node });
+    return () => h(FormKitSchema, { schema: schema.value, data: node.context, library }, __spreadValues({}, context.slots));
+  }
+});
+const optionsSymbol = Symbol.for("FormKitOptions");
+const invalidGet = Symbol();
+function watchVerbose(obj, callback) {
+  const watchers = {};
+  const applyWatch = (paths) => {
+    for (const path of paths) {
+      if (path.__str in watchers)
+        watchers[path.__str]();
+      watchers[path.__str] = watch(touch.bind(null, obj, path), dispatcher.bind(null, path), { deep: false });
+    }
+  };
+  const clearWatch = (path) => {
+    if (!path.length)
+      return;
+    for (const key in watchers) {
+      if (`${key}`.startsWith(`${path.__str}.`)) {
+        watchers[key]();
+        delete watchers[key];
+      }
+    }
+  };
+  const dispatcher = createDispatcher(obj, callback, applyWatch, clearWatch);
+  applyWatch(getPaths(obj));
+}
+function createDispatcher(obj, callback, applyWatch, clearChildWatches) {
+  return (path) => {
+    const value = get(obj, path);
+    if (value === invalidGet)
+      return;
+    if (path.__deep)
+      clearChildWatches(path);
+    if (typeof value === "object")
+      applyWatch(getPaths(value, [path], ...path));
+    callback(path, value, obj);
+  };
+}
+function touch(obj, path) {
+  const value = get(obj, path);
+  return value && typeof value === "object" ? Object.keys(value) : value;
+}
+function get(obj, path) {
+  if (isRef(obj)) {
+    if (path.length === 0)
+      return obj.value;
+    obj = obj.value;
+  }
+  return path.reduce((value, segment) => {
+    if (value === invalidGet)
+      return value;
+    if (value === null || typeof value !== "object") {
+      return invalidGet;
+    }
+    return value[segment];
+  }, obj);
+}
+function getPaths(obj, paths = [], ...parents) {
+  if (obj === null)
+    return paths;
+  if (!parents.length) {
+    const path = Object.defineProperty([], "__str", {
+      value: ""
+    });
+    obj = isRef(obj) ? obj.value : obj;
+    if (obj && typeof obj === "object") {
+      Object.defineProperty(path, "__deep", { value: true });
+      paths.push(path);
+    } else {
+      return [path];
+    }
+  }
+  if (obj === null || typeof obj !== "object")
+    return paths;
+  for (const key in obj) {
+    const path = parents.concat(key);
+    Object.defineProperty(path, "__str", { value: path.join(".") });
+    const value = obj[key];
+    if (isPojo(value) || Array.isArray(value)) {
+      paths.push(Object.defineProperty(path, "__deep", { value: true }));
+      paths = paths.concat(getPaths(value, [], ...path));
+    } else {
+      paths.push(path);
+    }
+  }
+  return paths;
+}
+function useRaw(obj) {
+  if (obj === null || typeof obj !== "object")
+    return obj;
+  if (isReactive(obj)) {
+    obj = toRaw(obj);
+  } else if (isRef(obj)) {
+    obj = isReactive(obj.value) ? useRaw(obj.value) : obj.value;
+  }
+  return obj;
+}
+const pseudoProps = [
+  "help",
+  "label",
+  "ignore",
+  "disabled",
+  "preserve",
+  /^preserve(-e|E)rrors/,
+  /^[a-z]+(?:-visibility|Visibility)$/,
+  /^[a-zA-Z-]+(?:-class|Class)$/
+];
+function classesToNodeProps(node, props2) {
+  if (props2.classes) {
+    Object.keys(props2.classes).forEach((key) => {
+      if (typeof key === "string") {
+        node.props[`_${key}Class`] = props2.classes[key];
+        if (isObject(props2.classes[key]) && key === "inner")
+          Object.values(props2.classes[key]);
+      }
+    });
+  }
+}
+function onlyListeners(props2) {
+  if (!props2)
+    return {};
+  const knownListeners = ["Submit", "SubmitRaw"].reduce((listeners, listener) => {
+    const name = `on${listener}`;
+    if (name in props2) {
+      if (typeof props2[name] === "function") {
+        listeners[name] = props2[name];
+      }
+    }
+    return listeners;
+  }, {});
+  return knownListeners;
+}
+function useInput(props2, context, options = {}) {
+  const config = Object.assign({}, inject(optionsSymbol) || {}, options);
+  const instance = getCurrentInstance();
+  const listeners = onlyListeners(instance === null || instance === void 0 ? void 0 : instance.vnode.props);
+  const isVModeled = props2.modelValue !== void 0;
+  const value = props2.modelValue !== void 0 ? props2.modelValue : cloneAny(context.attrs.value);
+  function createInitialProps() {
+    const initialProps2 = __spreadValues(__spreadValues({}, nodeProps(props2)), listeners);
+    const attrs = except(nodeProps(context.attrs), pseudoProps);
+    initialProps2.attrs = attrs;
+    const propValues = only(nodeProps(context.attrs), pseudoProps);
+    for (const propName in propValues) {
+      initialProps2[camel(propName)] = propValues[propName];
+    }
+    const classesProps = { props: {} };
+    classesToNodeProps(classesProps, props2);
+    Object.assign(initialProps2, classesProps.props);
+    if (typeof initialProps2.type !== "string") {
+      initialProps2.definition = initialProps2.type;
+      delete initialProps2.type;
+    }
+    return initialProps2;
+  }
+  const initialProps = createInitialProps();
+  const parent = initialProps.ignore ? null : props2.parent || inject(parentSymbol, null);
+  const node = createNode(extend(config || {}, {
+    name: props2.name || void 0,
+    value,
+    parent,
+    plugins: (config.plugins || []).concat(props2.plugins),
+    config: props2.config,
+    props: initialProps,
+    index: props2.index
+  }, false, true));
+  if (!node.props.definition)
+    error(600, node);
+  const lateBoundProps = ref(new Set(node.props.definition.props || []));
+  node.on("added-props", ({ payload: lateProps }) => {
+    if (Array.isArray(lateProps))
+      lateProps.forEach((newProp) => lateBoundProps.value.add(newProp));
+  });
+  const pseudoPropNames = computed(() => pseudoProps.concat([...lateBoundProps.value]).reduce((names, prop) => {
+    if (typeof prop === "string") {
+      names.push(camel(prop));
+      names.push(kebab(prop));
+    } else {
+      names.push(prop);
+    }
+    return names;
+  }, []));
+  watchEffect(() => classesToNodeProps(node, props2));
+  const passThrough = nodeProps(props2);
+  for (const prop in passThrough) {
+    watch(() => props2[prop], () => {
+      if (props2[prop] !== void 0) {
+        node.props[prop] = props2[prop];
+      }
+    });
+  }
+  const attributeWatchers = /* @__PURE__ */ new Set();
+  const possibleProps = nodeProps(context.attrs);
+  watchEffect(() => {
+    watchAttributes(only(possibleProps, pseudoPropNames.value));
+  });
+  function watchAttributes(attrProps) {
+    attributeWatchers.forEach((stop) => {
+      stop();
+      attributeWatchers.delete(stop);
+    });
+    for (const prop in attrProps) {
+      const camelName = camel(prop);
+      attributeWatchers.add(watch(() => context.attrs[prop], () => {
+        node.props[camelName] = context.attrs[prop];
+      }));
+    }
+  }
+  watchEffect(() => {
+    const attrs = except(nodeProps(context.attrs), pseudoPropNames.value);
+    node.props.attrs = Object.assign({}, node.props.attrs || {}, attrs);
+  });
+  watchEffect(() => {
+    const messages2 = props2.errors.map((error2) => createMessage({
+      key: slugify(error2),
+      type: "error",
+      value: error2,
+      meta: { source: "prop" }
+    }));
+    node.store.apply(messages2, (message2) => message2.type === "error" && message2.meta.source === "prop");
+  });
+  if (node.type !== "input") {
+    const sourceKey = `${node.name}-prop`;
+    watchEffect(() => {
+      const keys = Object.keys(props2.inputErrors);
+      const messages2 = keys.reduce((messages3, key) => {
+        let value2 = props2.inputErrors[key];
+        if (typeof value2 === "string")
+          value2 = [value2];
+        if (Array.isArray(value2)) {
+          messages3[key] = value2.map((error2) => createMessage({
+            key: error2,
+            type: "error",
+            value: error2,
+            meta: { source: sourceKey }
+          }));
+        }
+        return messages3;
+      }, {});
+      node.store.apply(messages2, (message2) => message2.type === "error" && message2.meta.source === sourceKey);
+    });
+  }
+  watchEffect(() => Object.assign(node.config, props2.config));
+  if (node.type !== "input") {
+    provide(parentSymbol, node);
+  }
+  let inputTimeout;
+  const mutex = /* @__PURE__ */ new WeakSet();
+  node.on("modelUpdated", () => {
+    var _a, _b;
+    context.emit("inputRaw", (_a = node.context) === null || _a === void 0 ? void 0 : _a.value, node);
+    clearTimeout(inputTimeout);
+    inputTimeout = setTimeout(context.emit, 20, "input", (_b = node.context) === null || _b === void 0 ? void 0 : _b.value, node);
+    if (isVModeled && node.context) {
+      const newValue = useRaw(node.context.value);
+      if (isObject(newValue) && useRaw(props2.modelValue) !== newValue) {
+        mutex.add(newValue);
+      }
+      context.emit("update:modelValue", newValue);
+    }
+  });
+  if (isVModeled) {
+    watchVerbose(toRef(props2, "modelValue"), (path, value2) => {
+      var _a;
+      const rawValue = useRaw(value2);
+      if (isObject(rawValue) && mutex.has(rawValue)) {
+        return mutex.delete(rawValue);
+      }
+      if (!path.length)
+        node.input(value2, false);
+      else
+        (_a = node.at(path)) === null || _a === void 0 ? void 0 : _a.input(value2, false);
+    });
+  }
+  onUnmounted(() => node.destroy());
+  return node;
+}
+let totalCreated = 1;
+function isComponent(obj) {
+  return typeof obj === "function" && obj.length === 2 || typeof obj === "object" && !Array.isArray(obj) && !("$el" in obj) && !("$cmp" in obj) && !("if" in obj);
+}
+function createInput(schemaOrComponent, definitionOptions = {}) {
+  const definition = __spreadValues({
+    type: "input"
+  }, definitionOptions);
+  let schema = void 0;
+  if (isComponent(schemaOrComponent)) {
+    const cmpName = `SchemaComponent${totalCreated++}`;
+    schema = () => ({
+      $cmp: cmpName,
+      props: {
+        context: "$node.context"
+      }
+    });
+    definition.library = { [cmpName]: markRaw(schemaOrComponent) };
+  } else {
+    schema = schemaOrComponent;
+  }
+  definition.schema = useSchema(schema || "Schema undefined");
+  return definition;
+}
+const _sfc_main$a = /* @__PURE__ */ defineComponent({
+  name: "PrimeInputText",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    const hasLeftIcon = () => {
+      return (context == null ? void 0 : context.iconLeft) && (context == null ? void 0 : context.iconLeft.length) > 0;
+    };
+    const hasRightIcon = () => {
+      return (context == null ? void 0 : context.iconRight) && (context == null ? void 0 : context.iconRight.length) > 0;
+    };
+    const spanClass = () => {
+      let result = "";
+      if (hasLeftIcon())
+        result = `${result}p-input-icon-left `;
+      if (hasRightIcon())
+        result = `${result}p-input-icon-right `;
+      return result;
+    };
+    function handleInput(e) {
+      context == null ? void 0 : context.node.input(e.target.value);
+    }
+    return (_ctx, _cache) => {
+      const _component_InputText = resolveComponent("InputText");
+      return openBlock(), createElementBlock("span", {
+        class: normalizeClass(spanClass())
+      }, [
+        hasLeftIcon() ? (openBlock(), createElementBlock("i", {
+          key: 0,
+          class: normalizeClass(unref(context).iconLeft)
+        }, null, 2)) : createCommentVNode("", true),
+        createVNode(_component_InputText, {
+          id: unref(context).id,
+          modelValue: unref(context)._value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+          placeholder: unref(context).attrs.placeholder,
+          class: normalizeClass(unref(context).attrs.class),
+          onInput: handleInput
+        }, null, 8, ["id", "modelValue", "placeholder", "class"]),
+        hasRightIcon ? (openBlock(), createElementBlock("i", {
+          key: 1,
+          class: normalizeClass(unref(context).iconRight)
+        }, null, 2)) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  name: "PrimeInputNumber",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      context == null ? void 0 : context.node.input(e.target.value);
+    }
+    return (_ctx, _cache) => {
+      var _a;
+      const _component_InputNumber = resolveComponent("InputNumber");
+      return openBlock(), createBlock(_component_InputNumber, {
+        id: unref(context).id,
+        modelValue: unref(context)._value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+        rows: (_a = unref(context).rows) != null ? _a : 3,
+        placeholder: unref(context).attrs.placeholder,
+        class: normalizeClass(unref(context).attrs.class),
+        onInput: handleInput
+      }, null, 8, ["id", "modelValue", "rows", "placeholder", "class"]);
+    };
+  }
+});
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  name: "PrimePassword",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      context == null ? void 0 : context.node.input(e.target.value);
+    }
+    return (_ctx, _cache) => {
+      var _a, _b, _c, _d;
+      const _component_Password = resolveComponent("Password");
+      return openBlock(), createBlock(_component_Password, {
+        id: unref(context).id,
+        modelValue: unref(context)._value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+        placeholder: unref(context).attrs.placeholder,
+        feedback: (_b = (_a = unref(context)) == null ? void 0 : _a.feedback) != null ? _b : true,
+        "toggle-mask": (_d = (_c = unref(context)) == null ? void 0 : _c.toggleMask) != null ? _d : false,
+        class: normalizeClass(unref(context).attrs.class),
+        onInput: handleInput
+      }, null, 8, ["id", "modelValue", "placeholder", "feedback", "toggle-mask", "class"]);
+    };
+  }
+});
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  name: "PrimeInputTextArea",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      context == null ? void 0 : context.node.input(e.target.value);
+    }
+    return (_ctx, _cache) => {
+      var _a;
+      const _component_Textarea = resolveComponent("Textarea");
+      return openBlock(), createBlock(_component_Textarea, {
+        id: unref(context).id,
+        modelValue: unref(context)._value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+        rows: (_a = unref(context).rows) != null ? _a : 3,
+        placeholder: unref(context).attrs.placeholder,
+        class: normalizeClass(unref(context).attrs.class),
+        onInput: handleInput
+      }, null, 8, ["id", "modelValue", "rows", "placeholder", "class"]);
+    };
+  }
+});
+const _hoisted_1$1 = {
+  key: 0,
+  class: "formkit-prime-left"
+};
+const _hoisted_2$1 = {
+  key: 1,
+  class: "formkit-prime-right"
+};
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  name: "PrimeCheckBox",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      context == null ? void 0 : context.node.input(e);
+    }
+    return (_ctx, _cache) => {
+      const _component_Checkbox = resolveComponent("Checkbox");
+      return openBlock(), createElementBlock(Fragment, null, [
+        unref(context).attrs.labelLeft ? (openBlock(), createElementBlock("span", _hoisted_1$1, toDisplayString(unref(context).attrs.labelLeft), 1)) : createCommentVNode("", true),
+        createVNode(_component_Checkbox, {
+          id: unref(context).id,
+          modelValue: unref(context)._value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+          placeholder: unref(context).attrs.placeholder,
+          binary: true,
+          class: normalizeClass(unref(context).attrs.class),
+          onInput: handleInput
+        }, null, 8, ["id", "modelValue", "placeholder", "class"]),
+        unref(context).attrs.labelRight ? (openBlock(), createElementBlock("span", _hoisted_2$1, toDisplayString(unref(context).attrs.labelRight), 1)) : createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+const _hoisted_1 = {
+  key: 0,
+  class: "formkit-prime-left"
+};
+const _hoisted_2 = {
+  key: 1,
+  class: "formkit-prime-right"
+};
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  name: "PrimeInputSwitch",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      var _a;
+      context == null ? void 0 : context.node.input((_a = props2.context) == null ? void 0 : _a._value);
+    }
+    return (_ctx, _cache) => {
+      var _a, _b;
+      const _component_InputSwitch = resolveComponent("InputSwitch");
+      return openBlock(), createElementBlock(Fragment, null, [
+        unref(context).attrs.labelLeft ? (openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(unref(context).attrs.labelLeft), 1)) : createCommentVNode("", true),
+        createVNode(_component_InputSwitch, {
+          id: unref(context).id,
+          modelValue: unref(context)._value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+          "true-value": (_a = unref(context).attrs.trueValue) != null ? _a : void 0,
+          "false-value": (_b = unref(context).attrs.falseValue) != null ? _b : void 0,
+          class: normalizeClass(unref(context).attrs.class),
+          onInput: handleInput
+        }, null, 8, ["id", "modelValue", "true-value", "false-value", "class"]),
+        unref(context).attrs.labelRight ? (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(unref(context).attrs.labelRight), 1)) : createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  name: "PrimeEditor",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      context == null ? void 0 : context.node.input(e.htmlValue);
+    }
+    return (_ctx, _cache) => {
+      const _component_Editor = resolveComponent("Editor");
+      return openBlock(), createBlock(_component_Editor, {
+        id: unref(context).id,
+        modelValue: unref(context)._value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+        placeholder: unref(context).attrs.placeholder,
+        onTextChange: handleInput
+      }, null, 8, ["id", "modelValue", "placeholder"]);
+    };
+  }
+});
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  name: "PrimeDropdown",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      context == null ? void 0 : context.node.input(e.value);
+    }
+    return (_ctx, _cache) => {
+      var _a, _b, _c, _d;
+      const _component_Dropdown = resolveComponent("Dropdown");
+      return openBlock(), createBlock(_component_Dropdown, {
+        id: unref(context).id,
+        modelValue: unref(context)._value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+        options: (_b = (_a = unref(context)) == null ? void 0 : _a.attrs) == null ? void 0 : _b.options,
+        "option-label": "label",
+        "option-value": "value",
+        placeholder: unref(context).attrs.placeholder,
+        filter: (_c = unref(context).attrs.filter) != null ? _c : false,
+        "show-clear": (_d = unref(context).attrs.showClear) != null ? _d : false,
+        class: normalizeClass(unref(context).attrs.class),
+        onChange: handleInput
+      }, null, 8, ["id", "modelValue", "options", "placeholder", "filter", "show-clear", "class"]);
+    };
+  }
+});
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  name: "PrimeMultiSelect",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      var _a;
+      context == null ? void 0 : context.node.input((_a = props2.context) == null ? void 0 : _a._value);
+    }
+    return (_ctx, _cache) => {
+      var _a, _b, _c;
+      const _component_MultiSelect = resolveComponent("MultiSelect");
+      return openBlock(), createBlock(_component_MultiSelect, {
+        id: unref(context).id,
+        modelValue: unref(context)._value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+        options: (_b = (_a = unref(context)) == null ? void 0 : _a.attrs) == null ? void 0 : _b.options,
+        "option-label": "label",
+        "option-value": "value",
+        placeholder: unref(context).attrs.placeholder,
+        filter: (_c = unref(context).attrs.filter) != null ? _c : false,
+        class: normalizeClass(unref(context).attrs.class),
+        onChange: handleInput
+      }, null, 8, ["id", "modelValue", "options", "placeholder", "filter", "class"]);
+    };
+  }
+});
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  name: "PrimeCalendar",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      context == null ? void 0 : context.node.input(context == null ? void 0 : context._value);
+    }
+    function handleSelect(e) {
+      context == null ? void 0 : context.node.input(e);
+    }
+    return (_ctx, _cache) => {
+      const _component_Calendar = resolveComponent("Calendar");
+      return openBlock(), createBlock(_component_Calendar, {
+        id: props2.context.id,
+        modelValue: unref(context)._value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+        class: normalizeClass(unref(context).attrs.class),
+        "date-format": unref(context).attrs.dateFormat,
+        "show-icon": unref(context).attrs.showIcon,
+        icon: unref(context).attrs.icon,
+        onDateSelect: handleSelect,
+        onInput: handleInput
+      }, null, 8, ["id", "modelValue", "class", "date-format", "show-icon", "icon"]);
+    };
+  }
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  name: "PrimeSlider",
+  props: {
+    context: Object
+  },
+  setup(__props) {
+    const props2 = __props;
+    const context = props2.context;
+    function handleInput(e) {
+      var _a;
+      context == null ? void 0 : context.node.input((_a = props2.context) == null ? void 0 : _a._value);
+    }
+    return (_ctx, _cache) => {
+      var _a, _b, _c, _d;
+      const _component_Slider = resolveComponent("Slider");
+      return openBlock(), createBlock(_component_Slider, {
+        id: unref(context).id,
+        modelValue: unref(context)._value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(context)._value = $event),
+        min: (_a = unref(context).attrs.min) != null ? _a : 0,
+        max: (_b = unref(context).attrs.max) != null ? _b : 100,
+        step: (_c = unref(context).attrs.step) != null ? _c : void 0,
+        range: (_d = unref(context).attrs.range) != null ? _d : false,
+        onChange: handleInput
+      }, null, 8, ["id", "modelValue", "min", "max", "step", "range"]);
+    };
+  }
+});
+const primeInputTextDefinition = createInput(_sfc_main$a, {
+  props: ["iconRight", "iconLeft"]
+});
+const primeInputNumberDefinition = createInput(_sfc_main$9, {
+  props: ["iconRight", "iconLeft"]
+});
+const primePasswordDefinition = createInput(_sfc_main$8, {
+  props: ["feedback", "toggleMask"]
+});
+const primeInputTextAreaDefinition = createInput(_sfc_main$7, {
+  props: ["rows"]
+});
+const primeCheckBoxDefinition = createInput(_sfc_main$6, {
+  props: []
+});
+const primeInputSwitchDefinition = createInput(_sfc_main$5, {
+  props: []
+});
+const primeEditorDefinition = createInput(_sfc_main$4, {
+  props: []
+});
+const primeDropdownDefinition = createInput(_sfc_main$3, {
+  props: []
+});
+const primeMultiSelectDefinition = createInput(_sfc_main$2, {
+  props: []
+});
+const primeCalendarDefinition = createInput(_sfc_main$1, {
+  props: []
+});
+const primeSliderDefinition = createInput(_sfc_main, {
+  props: []
+});
+const primeInputs = {
+  primeInputText: primeInputTextDefinition,
+  primeInputNumber: primeInputNumberDefinition,
+  primePassword: primePasswordDefinition,
+  primeCheckBox: primeCheckBoxDefinition,
+  primeInputSwitch: primeInputSwitchDefinition,
+  primeInputTextArea: primeInputTextAreaDefinition,
+  primeEditor: primeEditorDefinition,
+  primeDropdown: primeDropdownDefinition,
+  primeMultiSelect: primeMultiSelectDefinition,
+  primeCalendar: primeCalendarDefinition,
+  primeSlider: primeSliderDefinition
+};
+export { primeCalendarDefinition, primeCheckBoxDefinition, primeDropdownDefinition, primeEditorDefinition, primeInputNumberDefinition, primeInputSwitchDefinition, primeInputTextAreaDefinition, primeInputTextDefinition, primeInputs, primeMultiSelectDefinition, primePasswordDefinition, primeSliderDefinition };