attaform 0.0.1 → 0.14.0

package/dist/shared/attaform.CRgix6_n.cjs

@@ -0,0 +1,796 @@
+'use strict';
+
+const sensitiveNames = require('./attaform.B5GWYl76.cjs');
+const vue = require('vue');
+
+const isArray = Array.isArray;
+function isFunction(value) {
+  return typeof value === "function";
+}
+function toTypeString(value) {
+  return Object.prototype.toString.call(value);
+}
+function isSet(value) {
+  return toTypeString(value) === "[object Set]";
+}
+function isDate(value) {
+  return toTypeString(value) === "[object Date]";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function looseToNumber(val) {
+  const n = parseFloat(val);
+  return isNaN(n) ? val : n;
+}
+function looseCompareArrays(a, b) {
+  if (a.length !== b.length) return false;
+  let equal = true;
+  for (let i = 0; equal && i < a.length; i++) {
+    equal = looseEqual(a[i], b[i]);
+  }
+  return equal;
+}
+function looseEqual(a, b) {
+  if (a === b) return true;
+  const aValidType = isDate(a);
+  const bValidType = isDate(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+  }
+  const aSymbol = isSymbol(a);
+  const bSymbol = isSymbol(b);
+  if (aSymbol || bSymbol) return a === b;
+  const aIsArray = isArray(a);
+  const bIsArray = isArray(b);
+  if (aIsArray || bIsArray) {
+    return aIsArray && bIsArray ? looseCompareArrays(a, b) : false;
+  }
+  const aIsObject = isObject(a);
+  const bIsObject = isObject(b);
+  if (aIsObject !== bIsObject) return false;
+  if (aIsObject && bIsObject) {
+    const keysA = Object.keys(a);
+    if (keysA.length !== Object.keys(b).length) return false;
+    for (const key of keysA) {
+      const hasA = Object.prototype.hasOwnProperty.call(a, key);
+      const hasB = Object.prototype.hasOwnProperty.call(b, key);
+      if (!hasA || !hasB || !looseEqual(a[key], b[key])) return false;
+    }
+    return true;
+  }
+  return String(a) === String(b);
+}
+function looseIndexOf(arr, val) {
+  return arr.findIndex((item) => looseEqual(item, val));
+}
+function invokeArrayFns(fns, ...args) {
+  for (let i = 0; i < fns.length; i++) {
+    const fn = fns[i];
+    if (fn) fn(...args);
+  }
+}
+
+const assignKey = Symbol.for("attaform:assign-key");
+const listenersKey = Symbol.for("attaform:directive-listeners");
+function isRegisterValue(val) {
+  if (typeof val !== "object" || val === null) return false;
+  if (!("innerRef" in val)) return false;
+  if (!vue.isRef(val.innerRef)) return false;
+  if (!("registerElement" in val)) return false;
+  if (typeof val.registerElement !== "function") return false;
+  if (!("setValueWithInternalPath" in val)) return false;
+  if (typeof val.setValueWithInternalPath !== "function") return false;
+  return true;
+}
+function addEventListener(el, event, handler, options) {
+  el.addEventListener(event, handler, options);
+  const carrier = el;
+  const bag = carrier[listenersKey] ?? [];
+  bag.push({ event, handler, options });
+  carrier[listenersKey] = bag;
+}
+function removeTrackedListeners(el) {
+  const carrier = el;
+  const bag = carrier[listenersKey];
+  if (bag === void 0) return;
+  for (const { event, handler, options } of bag) {
+    el.removeEventListener(event, handler, options);
+  }
+  delete carrier[listenersKey];
+}
+function computePersistMeta(el, registerValue) {
+  const elementId = sensitiveNames.getOrAssignElementId(el);
+  return { persist: registerValue.persistOptIns.hasOptIn(elementId, registerValue.path) };
+}
+const DEFAULT_ASSIGNER_TAG = Symbol.for("attaform:default-assigner-tag");
+function isDefaultAssigner(fn) {
+  return typeof fn === "function" && fn[DEFAULT_ASSIGNER_TAG] === true;
+}
+function shouldBailListener(el) {
+  if (SUPPORTED_TAGS.has(el.tagName)) return false;
+  return isDefaultAssigner(el[assignKey]);
+}
+function runTransforms(initial, registerValue) {
+  const transforms = registerValue.transforms;
+  if (transforms === void 0 || transforms.length === 0) {
+    return { ok: true, value: initial };
+  }
+  let v = initial;
+  for (let i = 0; i < transforms.length; i++) {
+    const fn = transforms[i];
+    try {
+      v = fn(v);
+    } catch (err) {
+      logTransformFailure(registerValue.path, i, fn, err);
+      return { ok: false };
+    }
+  }
+  if (v instanceof Promise) {
+    logTransformAsync(registerValue.path);
+    return { ok: false };
+  }
+  return { ok: true, value: v };
+}
+function logTransformFailure(path, index, fn, err) {
+  if (sensitiveNames.__DEV__) {
+    const namePart = fn.name !== "" ? `, '${fn.name}'` : "";
+    console.error(
+      `[attaform] transform threw for path '${path}' (index ${index}${namePart}) \u2014 write aborted. Transforms must not throw; wrap your own try/catch if the throw is recoverable. Original error:`,
+      err
+    );
+  } else {
+    console.error(
+      `[attaform] transform error \u2014 write aborted (set NODE_ENV=development for details).`
+    );
+  }
+}
+function applyCoerce(value, registerValue) {
+  return registerValue.coerce !== void 0 ? registerValue.coerce(value) : value;
+}
+function applyElementCoerce(value, registerValue) {
+  return registerValue.coerceElement !== void 0 ? registerValue.coerceElement(value) : value;
+}
+function logTransformAsync(path) {
+  if (sensitiveNames.__DEV__) {
+    console.error(
+      `[attaform] transform pipeline for path '${path}' returned a Promise \u2014 transforms must be sync. Use async field validation for canonicalize-before-write patterns. Write aborted.`
+    );
+  } else {
+    console.error(
+      `[attaform] transform error \u2014 write aborted (set NODE_ENV=development for details).`
+    );
+  }
+}
+const getModelAssigner = (el, vnode, registerValue) => {
+  const fn = vnode.props?.["onUpdate:registerValue"] ?? vnode.props?.["on:update:registerValue"];
+  if (isArray(fn)) {
+    const fnArr = fn.filter((x) => isFunction(x));
+    return (value) => {
+      const r = runTransforms(value, registerValue);
+      if (!r.ok) return false;
+      const coerced = applyCoerce(r.value, registerValue);
+      invokeArrayFns(fnArr, coerced, registerValue);
+      return void 0;
+    };
+  }
+  if (isFunction(fn)) {
+    const handler = fn;
+    return (value) => {
+      const r = runTransforms(value, registerValue);
+      if (!r.ok) return false;
+      const coerced = applyCoerce(r.value, registerValue);
+      return handler(coerced, registerValue);
+    };
+  }
+  const defaultAssigner = (value) => {
+    const r = runTransforms(value, registerValue);
+    if (!r.ok) return false;
+    const coerced = applyCoerce(r.value, registerValue);
+    return registerValue.setValueWithInternalPath(coerced, computePersistMeta(el, registerValue));
+  };
+  defaultAssigner[DEFAULT_ASSIGNER_TAG] = true;
+  return defaultAssigner;
+};
+function syncPersistOptIn(el, value, oldValue) {
+  const wasOptedIn = isRegisterValue(oldValue) && oldValue.persist === true;
+  const wantsOptIn = isRegisterValue(value) && value.persist === true;
+  if (!wasOptedIn && !wantsOptIn) return;
+  const elementId = sensitiveNames.getOrAssignElementId(el);
+  if (wasOptedIn) {
+    const old = oldValue;
+    const samePathAndRegistry = wantsOptIn && value.path === old.path && value.persistOptIns === old.persistOptIns;
+    if (!samePathAndRegistry) {
+      old.persistOptIns.remove(elementId, old.path);
+    }
+  }
+  if (wantsOptIn) {
+    const v = value;
+    sensitiveNames.enforceSensitiveCheck(v.path, v.acknowledgeSensitive);
+    v.persistOptIns.add(elementId, v.path);
+  }
+}
+function syncElementRegistration(el, value, oldValue) {
+  const wasRegistered = isRegisterValue(oldValue);
+  const isRegistered = isRegisterValue(value);
+  if (!wasRegistered && !isRegistered) return;
+  if (wasRegistered && isRegistered) {
+    const old = oldValue;
+    const next = value;
+    if (old.path === next.path && old.persistOptIns === next.persistOptIns) return;
+  }
+  if (wasRegistered) {
+    oldValue.deregisterElement(el);
+  }
+  if (isRegistered) {
+    value.registerElement(el);
+  }
+}
+function onCompositionStart(e) {
+  const target = e.target;
+  if (!target) return;
+  target.composing = true;
+}
+function onCompositionEnd(e) {
+  const target = e.target;
+  if (target?.composing === true) {
+    target.composing = false;
+    target.dispatchEvent(new Event("input"));
+  }
+}
+function makeNoopAssigner() {
+  const noop = (_) => void 0;
+  noop[DEFAULT_ASSIGNER_TAG] = true;
+  return noop;
+}
+function setAssignFunction(el, vnode, value) {
+  if (el[assignKey] !== void 0 && !isDefaultAssigner(el[assignKey])) {
+    return;
+  }
+  if (value === void 0) {
+    el[assignKey] = makeNoopAssigner();
+    return;
+  }
+  if (!isRegisterValue(value)) {
+    vue.warn(
+      `v-register expected a RegisterValue, got '${typeof value}'. Bind to form.register('field') \u2014 not the field's ref, value, or path string.`
+    );
+    el[assignKey] = makeNoopAssigner();
+    return;
+  }
+  el[assignKey] = getModelAssigner(el, vnode, value);
+}
+const vRegisterText = {
+  created(el, { value, modifiers: { lazy, trim, number } }, vnode) {
+    const castToNumber = number === true || vnode.props?.["type"] === "number";
+    if (isRegisterValue(value)) {
+      value.registerElement(el);
+      setAssignFunction(el, vnode, value);
+    }
+    addEventListener(el, lazy === true ? "change" : "input", (e) => {
+      if (shouldBailListener(el)) return;
+      const target = e.target;
+      if (target === null || target.composing) return;
+      let domValue = el.value;
+      if (trim === true && lazy === true) {
+        domValue = domValue.trim();
+      }
+      if (castToNumber) {
+        if (domValue === "") {
+          const validity = el.validity;
+          if (validity?.badInput === true) {
+            return;
+          }
+          if (isRegisterValue(value)) {
+            value.lastTypedForm.value = null;
+            value.markBlank();
+          }
+          return;
+        }
+        const typedString = domValue;
+        domValue = looseToNumber(domValue);
+        if (typeof domValue !== "number") {
+          if (isRegisterValue(value)) {
+            value.lastTypedForm.value = null;
+            value.markBlank();
+          }
+          return;
+        }
+        if (!Number.isFinite(domValue)) {
+          if (isRegisterValue(value)) {
+            const target2 = value.displayValue.value;
+            if (el.value !== target2) el.value = target2;
+          }
+          return;
+        }
+        if (isRegisterValue(value)) value.lastTypedForm.value = typedString;
+      }
+      el[assignKey]?.(domValue);
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+        const storage = value.innerRef.value;
+        if (storage !== domValue) {
+          const display = storage == null ? "" : String(storage);
+          if (el.value !== display) el.value = display;
+          if (castToNumber) value.lastTypedForm.value = null;
+        }
+      }
+    });
+    if (trim === true || castToNumber) {
+      addEventListener(el, "change", () => {
+        if (shouldBailListener(el)) return;
+        let normalized = el.value;
+        if (trim === true) normalized = normalized.trim();
+        if (castToNumber) {
+          const cast = looseToNumber(normalized);
+          if (typeof cast === "number" && Number.isFinite(cast)) {
+            if (isRegisterValue(value)) value.lastTypedForm.value = null;
+            el.value = String(cast);
+            if (lazy !== true) el[assignKey]?.(cast);
+          } else {
+            if (isRegisterValue(value)) {
+              value.lastTypedForm.value = null;
+              value.markBlank();
+            }
+            el.value = "";
+          }
+          return;
+        }
+        el.value = typeof normalized === "number" ? String(normalized) : normalized;
+        if (trim === true && lazy !== true) {
+          el[assignKey]?.(normalized);
+        }
+      });
+    }
+    if (lazy !== true) {
+      addEventListener(el, "compositionstart", onCompositionStart);
+      addEventListener(el, "compositionend", onCompositionEnd);
+      addEventListener(el, "change", onCompositionEnd);
+    }
+    if (number === true && vnode.props?.["type"] !== "number") {
+      addEventListener(el, "beforeinput", (e) => {
+        const ev = e;
+        if (ev.inputType !== "insertText" && ev.inputType !== "insertFromPaste" && ev.inputType !== "insertFromDrop") {
+          return;
+        }
+        const data = ev.data;
+        if (data === null) return;
+        const start = el.selectionStart ?? 0;
+        const end = el.selectionEnd ?? 0;
+        const next = el.value.slice(0, start) + data + el.value.slice(end);
+        if (!/^-?\d*\.?\d*([eE][+-]?\d*)?$/.test(next)) ev.preventDefault();
+      });
+    }
+  },
+  // set value on mounted so it's after min/max for type="range"
+  mounted(el, { value }) {
+    if (!isRegisterValue(value)) return;
+    const _val = value.innerRef.value;
+    el.value = typeof _val === "string" || typeof _val === "number" ? `${_val}` : "";
+  },
+  beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
+    setAssignFunction(el, vnode, value);
+    if (el.composing === true) return;
+    if (!isRegisterValue(value)) return;
+    const elValue = (number === true || el.type === "number") && !/^0\d/.test(el.value) ? looseToNumber(el.value) : el.value;
+    const newValue = value.innerRef.value === null ? "" : value.innerRef.value;
+    if (elValue === newValue) {
+      return;
+    }
+    const rootNode = el.getRootNode();
+    const activeElement = rootNode instanceof Document || rootNode instanceof ShadowRoot ? rootNode.activeElement : null;
+    if (activeElement === el && el.type !== "range") {
+      if (lazy === true && value.innerRef.value === oldValue) {
+        return;
+      }
+      if (trim === true && el.value.trim() === newValue) {
+        return;
+      }
+    }
+    el.value = newValue == null ? "" : String(newValue);
+  }
+};
+const vRegisterCheckbox = {
+  // #4096 array checkboxes need to be deep traversed
+  deep: true,
+  created(el, { value }, vnode) {
+    if (!isRegisterValue(value)) return;
+    value.registerElement(el);
+    setAssignFunction(el, vnode, value);
+    addEventListener(el, "change", () => {
+      if (shouldBailListener(el)) return;
+      const modelValue = value.innerRef.value ?? [];
+      const explicitValueRequired = true;
+      const rawElementValue = getValue(el, explicitValueRequired);
+      const checked = el.checked;
+      const assign = el[assignKey];
+      if (isArray(modelValue)) {
+        if (rawElementValue === void 0) {
+          vue.warn(
+            'Checkbox bound to an array model is missing a `value` attribute \u2014 cannot determine which item to add or remove. Add value="..." to each <input type="checkbox">.'
+          );
+          return;
+        }
+        const elementValue = applyElementCoerce(rawElementValue, value);
+        const index = looseIndexOf(modelValue, elementValue);
+        const found = index !== -1;
+        if (checked && !found) {
+          assign?.(modelValue.concat(elementValue));
+        } else if (!checked && found) {
+          const filtered = [...modelValue];
+          filtered.splice(index, 1);
+          assign?.(filtered);
+        }
+      } else if (isSet(modelValue)) {
+        if (rawElementValue === void 0) {
+          vue.warn(
+            'Checkbox bound to a Set model is missing a `value` attribute \u2014 cannot determine which item to add or remove. Add value="..." to each <input type="checkbox">.'
+          );
+          return;
+        }
+        const elementValue = applyElementCoerce(rawElementValue, value);
+        const cloned = new Set(modelValue);
+        if (checked) {
+          cloned.add(elementValue);
+        } else {
+          cloned.delete(elementValue);
+        }
+        assign?.(cloned);
+      } else {
+        assign?.(getCheckboxValue(el, checked));
+      }
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+        setChecked(el, value);
+        el._lastAppliedModel = value.innerRef.value;
+      }
+    });
+  },
+  // set initial checked on mount to wait for true-value/false-value
+  mounted(el, { value }) {
+    setChecked(el, value);
+    if (isRegisterValue(value)) el._lastAppliedModel = value.innerRef.value;
+  },
+  // Skip the DOM sync when the model is identity-unchanged from the
+  // last application. Pre-fix the scalar branch in `setChecked`
+  // gated on `originalValue === oldValue`, comparing a primitive
+  // scalar against the wrapper RegisterValue object — always !==,
+  // so the guard was a silent no-op. Array / Set branches lacked
+  // any guard. The per-render re-apply mirrors the just-fixed
+  // `vRegisterSelect` shape: a sibling's reactive write triggers
+  // `beforeUpdate` mid-click, `setChecked` re-applies the prior
+  // model state, and the in-flight user toggle is clobbered before
+  // the browser fires `change`. Identity comparison on
+  // `innerRef.value` is sound for the same reason as multi-select —
+  // every form write produces a fresh value at the path (new
+  // primitives; new array/Set references along the spine), so
+  // reference equality tracks "did the model move" exactly.
+  beforeUpdate(el, binding, vnode) {
+    setAssignFunction(el, vnode, binding.value);
+    if (!isRegisterValue(binding.value)) return;
+    const currentModel = binding.value.innerRef.value;
+    if (el._lastAppliedModel === currentModel) return;
+    setChecked(el, binding.value);
+    el._lastAppliedModel = currentModel;
+  }
+};
+function setChecked(el, value) {
+  if (!isRegisterValue(value)) return;
+  const originalValue = value.innerRef.value;
+  let checked;
+  if (isArray(originalValue)) {
+    checked = looseIndexOf(originalValue, applyElementCoerce(getValue(el), value)) > -1;
+  } else if (isSet(originalValue)) {
+    checked = originalValue.has(applyElementCoerce(getValue(el), value));
+  } else {
+    const trueValueCoerced = applyCoerce(getCheckboxValue(el, true), value);
+    checked = looseEqual(originalValue, trueValueCoerced);
+  }
+  if (el.checked !== checked) {
+    el.checked = checked;
+  }
+}
+const vRegisterRadio = {
+  created(el, { value }, vnode) {
+    if (!isRegisterValue(value)) return;
+    value.registerElement(el);
+    setAssignFunction(el, vnode, value);
+    addEventListener(el, "change", () => {
+      if (shouldBailListener(el)) return;
+      el[assignKey]?.(getValue(el));
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+        const currentModel = value.innerRef.value;
+        const target = looseEqual(currentModel, applyCoerce(getValue(el), value));
+        if (el.checked !== target) el.checked = target;
+        el._lastAppliedModel = currentModel;
+      }
+    });
+  },
+  // Initial checked-state sync runs in `mounted`, NOT `created` —
+  // Vue's directive lifecycle fires `created` BEFORE the element's
+  // attributes are patched (`type`, `value`, `_value` etc. aren't on
+  // the element yet), so `getValue(el)` would return `undefined` and
+  // every radio in a group would mount unchecked regardless of the
+  // model. Checkbox already uses `mounted: setChecked` for the same
+  // reason.
+  mounted(el, { value }) {
+    if (!isRegisterValue(value)) return;
+    el.checked = looseEqual(value.innerRef.value, applyCoerce(getValue(el), value));
+    el._lastAppliedModel = value.innerRef.value;
+  },
+  // Skip the DOM sync when the model is identity-unchanged from the
+  // last application. Pre-fix the guard read `value.innerRef.value
+  // !== oldValue`, comparing a primitive scalar against the previous
+  // binding's wrapper RegisterValue object — always !==, so the
+  // guard was a silent no-op and `el.checked = …` re-applied on
+  // every parent re-render. Same shape as the just-fixed
+  // `vRegisterSelect` and `setChecked` bugs: a sibling's reactive
+  // write triggers `beforeUpdate` mid-click and writes back the
+  // prior model state, clobbering the in-flight selection.
+  beforeUpdate(el, { value }, vnode) {
+    if (!isRegisterValue(value)) return;
+    setAssignFunction(el, vnode, value);
+    const currentModel = value.innerRef.value;
+    if (el._lastAppliedModel === currentModel) return;
+    el.checked = looseEqual(currentModel, applyCoerce(getValue(el), value));
+    el._lastAppliedModel = currentModel;
+  }
+};
+const vRegisterSelect = {
+  // <select multiple> value need to be deep traversed
+  deep: true,
+  created(el, { value, modifiers: { number } }, vnode) {
+    if (!isRegisterValue(value)) return;
+    value.registerElement(el);
+    const isSetModel = isSet(value.innerRef.value);
+    addEventListener(el, "change", () => {
+      if (shouldBailListener(el)) return;
+      const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map((o) => number === true ? looseToNumber(getValue(o)) : getValue(o));
+      const wrote = el[assignKey]?.(
+        el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
+      );
+      if (wrote !== false) {
+        el._assigning = true;
+        void vue.nextTick(() => {
+          el._assigning = false;
+        });
+      }
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+        setSelected(el, value);
+        el._lastAppliedModel = value.innerRef.value;
+      }
+    });
+    setAssignFunction(el, vnode, value);
+  },
+  // set value in mounted & updated because <select> relies on its children
+  // <option>s.
+  mounted(el, { value }) {
+    setSelected(el, value);
+    if (isRegisterValue(value)) el._lastAppliedModel = value.innerRef.value;
+  },
+  beforeUpdate(el, binding, vnode) {
+    setAssignFunction(el, vnode, binding.value);
+  },
+  // Skip the DOM sync when the model is identity-unchanged from the
+  // last application. Parent re-renders fire `updated` whether or not
+  // the bound model actually moved (a typed character in a sibling,
+  // an async-validation tick, any reactive read elsewhere on the
+  // page). Without this guard, every such render unconditionally re-
+  // applies `setSelected` against the prior model, which on a
+  // `<select multiple>` clobbers any in-progress user selection
+  // between mousedown and the browser's change-event decision — the
+  // browser then sees no net change, never fires `change`, and the
+  // model never updates. Identity comparison is sound: every form
+  // write produces a new array/Set reference at the path (the diff-
+  // apply replacement of `form.value` rolls forward fresh structures
+  // along the spine), so reference equality on `innerRef.value`
+  // tracks "did the model move" exactly. The `_assigning` gate stays
+  // — it short-circuits the immediate post-write render where the
+  // DOM is already in sync from the user's click.
+  updated(el, { value }) {
+    if (el._assigning === true) return;
+    if (!isRegisterValue(value)) return;
+    const currentModel = value.innerRef.value;
+    if (el._lastAppliedModel === currentModel) return;
+    setSelected(el, value);
+    el._lastAppliedModel = currentModel;
+  }
+};
+function setSelected(el, value) {
+  if (!isRegisterValue(value)) return;
+  const externalValue = value.innerRef.value;
+  const isMultiple = el.multiple;
+  const isArrayValue = isArray(externalValue);
+  if (isMultiple && !isArrayValue && !isSet(externalValue)) {
+    if (sensitiveNames.__DEV__) {
+      vue.warn(
+        `<select multiple v-register> expected an Array or Set, got ${Object.prototype.toString.call(externalValue).slice(8, -1)}. Bind to a list-typed schema (e.g. z.array(z.string()) or z.set(z.string())).`
+      );
+    }
+    return;
+  }
+  if (!isMultiple && (isArrayValue || isSet(externalValue))) {
+    if (sensitiveNames.__DEV__) {
+      vue.warn(
+        `<select v-register> (no \`multiple\` attribute) expected a scalar value for its binding, but got ${Object.prototype.toString.call(externalValue).slice(8, -1)}. Add the \`multiple\` attribute to bind to a list, or use a scalar schema (e.g. \`z.string()\`) for a single-select binding.`
+      );
+    }
+    return;
+  }
+  if (isMultiple) {
+    const stringifiedMembers = /* @__PURE__ */ new Set();
+    const iter = isArrayValue ? externalValue : externalValue;
+    for (const v of iter) stringifiedMembers.add(String(v));
+    for (let i = 0, l = el.options.length; i < l; i++) {
+      const option = el.options[i];
+      if (!option) continue;
+      const optionValue = applyElementCoerce(getValue(option), value);
+      const optionType = typeof optionValue;
+      if (optionType === "string" || optionType === "number") {
+        option.selected = stringifiedMembers.has(String(optionValue));
+      } else if (optionType === "boolean") {
+        option.selected = stringifiedMembers.has(String(optionValue));
+      } else if (isArrayValue) {
+        option.selected = looseIndexOf(externalValue, optionValue) > -1;
+      } else {
+        option.selected = externalValue.has(optionValue);
+      }
+    }
+    return;
+  }
+  for (let i = 0, l = el.options.length; i < l; i++) {
+    const option = el.options[i];
+    if (!option) continue;
+    if (looseEqual(applyCoerce(getValue(option), value), externalValue)) {
+      if (el.selectedIndex !== i) el.selectedIndex = i;
+      return;
+    }
+  }
+  if (el.selectedIndex !== -1) el.selectedIndex = -1;
+}
+function getValue(el, explicitRequired = false) {
+  if ("_value" in el) return el._value;
+  if (explicitRequired && !el.hasAttribute("value")) return void 0;
+  return el.value;
+}
+function getCheckboxValue(el, checked) {
+  const key = checked ? "_trueValue" : "_falseValue";
+  return key in el ? el[key] : checked;
+}
+const SUPPORTED_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
+const warnedUnsupportedElements = sensitiveNames.__DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+const vRegisterDynamic = {
+  created(el, binding, vnode) {
+    syncPersistOptIn(el, binding.value, void 0);
+    callModelHook(el, binding, vnode, null, "created");
+    if (sensitiveNames.__DEV__ && warnedUnsupportedElements !== null && !SUPPORTED_TAGS.has(el.tagName) && !warnedUnsupportedElements.has(el)) {
+      void vue.nextTick(() => {
+        if (warnedUnsupportedElements.has(el)) return;
+        const hasMarker = el[sensitiveNames.REGISTER_OWNER_MARKER] === true;
+        const hasUserAssigner = !isDefaultAssigner(
+          el[assignKey]
+        );
+        if (hasMarker || hasUserAssigner) return;
+        warnedUnsupportedElements.add(el);
+        vue.warn(
+          `[attaform] v-register on <${el.tagName.toLowerCase()}> is a no-op \u2014 non-input roots aren't bound to text-input semantics. For custom components: call \`useRegister()\` in the child's setup and re-bind v-register to an inner native element. Lower-level: install a custom assigner via the \`assignKey\` symbol on the element.`
+        );
+      });
+    }
+  },
+  mounted(el, binding, vnode) {
+    callModelHook(el, binding, vnode, null, "mounted");
+  },
+  beforeUpdate(el, binding, vnode, prevVNode) {
+    syncPersistOptIn(el, binding.value, binding.oldValue);
+    syncElementRegistration(el, binding.value, binding.oldValue);
+    callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
+  },
+  updated(el, binding, vnode, prevVNode) {
+    callModelHook(el, binding, vnode, prevVNode, "updated");
+  },
+  beforeUnmount(el, { value }) {
+    removeTrackedListeners(el);
+    if (isRegisterValue(value)) {
+      value.persistOptIns.removeAllFor(sensitiveNames.getOrAssignElementId(el));
+    }
+    if (!isRegisterValue(value)) return;
+    value.deregisterElement(el);
+    delete el.composing;
+    delete el._assigning;
+    delete el[assignKey];
+  }
+};
+const vRegisterFileNoop = {
+  created(el, { value }) {
+    if (!isRegisterValue(value)) return;
+    value.registerElement(el);
+    if (sensitiveNames.__DEV__) {
+      vue.warn(
+        '[attaform] v-register on <input type="file"> is not supported. Handle uploads with a manual @change listener.'
+      );
+    }
+  },
+  beforeUnmount(el, { value }) {
+    removeTrackedListeners(el);
+    if (!isRegisterValue(value)) return;
+    value.deregisterElement(el);
+  }
+};
+function resolveDynamicModel(tagName, type) {
+  if (tagName === "SELECT") return vRegisterSelect;
+  if (tagName === "TEXTAREA") return vRegisterText;
+  if (typeof type !== "string") return vRegisterText;
+  if (type === "file") return vRegisterFileNoop;
+  if (type === "checkbox") return vRegisterCheckbox;
+  if (type === "radio") return vRegisterRadio;
+  return vRegisterText;
+}
+function callModelHook(el, binding, vnode, prevVNode, hook) {
+  const modelToUse = resolveDynamicModel(el.tagName, vnode.props?.["type"]);
+  const fn = modelToUse[hook];
+  fn?.(el, binding, vnode, prevVNode);
+}
+const vRegister = vRegisterDynamic;
+
+function createAttaform(options = {}) {
+  const plugin = {
+    install(app) {
+      if (app._attaform !== void 0) {
+        if (sensitiveNames.__DEV__) {
+          console.warn(
+            "[attaform] createAttaform() install was called twice on the same app; the second call is a no-op. Likely cause: registering the plugin via both the Nuxt module AND a manual `app.use(...)`."
+          );
+        }
+        return;
+      }
+      const registry = sensitiveNames.createRegistry(options);
+      sensitiveNames.attachRegistryToApp(app, registry);
+      app.directive("register", vRegister);
+      if (options.devtools !== false && !registry.isSSR) {
+        void (async () => {
+          try {
+            const { setupAttaformDevtools } = await import('../chunks/devtools.cjs');
+            await setupAttaformDevtools(app, registry);
+          } catch {
+          }
+        })();
+      }
+    }
+  };
+  return plugin;
+}
+
+function renderAttaformState(app) {
+  const registry = sensitiveNames.getRegistryFromApp(app);
+  const forms = [];
+  for (const [key, state] of registry.forms) {
+    const transientList = Array.from(state.blankPaths);
+    forms.push([
+      key,
+      {
+        form: state.form.value,
+        schemaErrors: Array.from(state.schemaErrors.entries()),
+        userErrors: Array.from(state.userErrors.entries()),
+        fields: Array.from(state.fields.entries()),
+        ...transientList.length > 0 ? { blankPaths: transientList } : {}
+      }
+    ]);
+  }
+  return { forms };
+}
+function hydrateAttaformState(app, payload) {
+  const registry = sensitiveNames.getRegistryFromApp(app);
+  for (const [key, data] of payload.forms) {
+    registry.pendingHydration.set(key, data);
+  }
+}
+
+exports.assignKey = assignKey;
+exports.createAttaform = createAttaform;
+exports.hydrateAttaformState = hydrateAttaformState;
+exports.isRegisterValue = isRegisterValue;
+exports.renderAttaformState = renderAttaformState;
+exports.vRegister = vRegister;
+//# sourceMappingURL=attaform.CRgix6_n.cjs.map