attaform 0.27.5 → 0.28.0

package/dist/shared/attaform.Bn0IzhD_.cjs

@@ -1,800 +0,0 @@
-'use strict';
-
-const compilerCore = require('@vue/compiler-core');
-const registerProtocol = require('./attaform.yUrz7C2z.cjs');
-
-function getSummarizedProps(node) {
-  if (!("props" in node)) return [];
-  const props = node.props;
-  const summarizedProps = props.reduce((acc, currProp) => {
-    if (currProp.type === compilerCore.NodeTypes.ATTRIBUTE) {
-      const key2 = currProp.name;
-      const value2 = currProp.value?.content ?? "";
-      return [...acc, { key: key2, value: renderAsStatic(value2, true) }];
-    }
-    if (currProp.exp === void 0) return acc;
-    const key = currProp.arg ? getSummarizedPropValue(currProp.arg) : renderAsStatic(currProp.name, true);
-    if (typeof key !== "string") return acc;
-    const value = getSummarizedPropValue(currProp.exp);
-    return [...acc, { key, value }];
-  }, []);
-  return summarizedProps;
-}
-function renderAsStatic(val, isStatic) {
-  return isStatic ? `"${val}"` : val;
-}
-function getSummarizedPropValue(exp) {
-  if (exp.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION) {
-    return renderAsStatic(exp.content, exp.isStatic);
-  }
-  return exp.children;
-}
-function removePropsByName(props, propNames) {
-  const removePropIndices = [];
-  for (let index = 0; index < props.length; index++) {
-    const prop = props[index];
-    if (!prop) continue;
-    if (propNames.includes(prop.name) || "arg" in prop && prop.arg && "content" in prop.arg && propNames.includes(prop.arg.content)) {
-      removePropIndices.push(index);
-    }
-  }
-  for (const index of removePropIndices.sort((a, z) => z - a)) {
-    props.splice(index, 1);
-  }
-}
-function isExactKey(summarizedKey, name) {
-  return summarizedKey === name || summarizedKey === `"${name}"`;
-}
-function flattenExpression(exp) {
-  if (exp.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION) return exp.content;
-  let out = "";
-  for (const child of exp.children) {
-    if (typeof child === "string") {
-      out += child;
-      continue;
-    }
-    if (typeof child === "symbol") continue;
-    const node = child;
-    if (node.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION) {
-      out += node.content;
-      continue;
-    }
-    if (node.type === compilerCore.NodeTypes.COMPOUND_EXPRESSION) {
-      out += flattenExpression(node);
-    }
-  }
-  return out;
-}
-
-function generateEqualityExpression$1(selectValue, optionValue, previousOptionExpressions) {
-  const multipleExpression = previousOptionExpressions?.[0];
-  if (multipleExpression === void 0) {
-    throw new Error(
-      "Programming error: `multiple` expression for `select` node not generated while transforming AST"
-    );
-  }
-  const optExpressions = previousOptionExpressions.slice(1);
-  const noMultipleOptExpressions = optExpressions.reduce(
-    (acc, curr, index) => {
-      if (index === 0) {
-        acc.push("(");
-      }
-      acc.push(...curr);
-      if (index < optExpressions.length - 1) {
-        acc.push(" || ");
-      }
-      if (index === optExpressions.length - 1) {
-        acc.push(")");
-      }
-      return acc;
-    },
-    []
-  );
-  const selectValueArr = Array.isArray(selectValue) ? selectValue : [selectValue];
-  const optionValueArr = Array.isArray(optionValue) ? optionValue : [optionValue];
-  function getImplicitTrueMultipleExpression(expression) {
-    if (expression.length === 1 && expression[0] === "") return [`true`];
-    return expression;
-  }
-  previousOptionExpressions.push(["(", ...selectValueArr, ") === (", ...optionValueArr, ")"]);
-  if (!noMultipleOptExpressions.length) {
-    return [
-      "(",
-      ...getImplicitTrueMultipleExpression(multipleExpression),
-      `) ? ((`,
-      ...selectValueArr,
-      `)?.innerRef?.value?.findIndex?.(el => el === (`,
-      ...optionValueArr,
-      `)) > -1) : (typeof (`,
-      ...selectValueArr,
-      `)?.innerRef?.value !== 'object' && String((`,
-      ...selectValueArr,
-      `)?.innerRef?.value) === String((`,
-      ...optionValueArr,
-      `)))`
-    ];
-  }
-  return [
-    "(",
-    ...getImplicitTrueMultipleExpression(multipleExpression),
-    `) ? ((`,
-    ...selectValueArr,
-    `)?.innerRef?.value?.findIndex?.(el => el === (`,
-    ...optionValueArr,
-    `)) > -1) : ((`,
-    ...noMultipleOptExpressions,
-    // if true, we already found the relevant option
-    `) ? false : (typeof (`,
-    ...selectValueArr,
-    `)?.innerRef?.value !== 'object' && String((`,
-    ...selectValueArr,
-    `)?.innerRef?.value) === String((`,
-    ...optionValueArr,
-    `))))`
-  ];
-}
-function extractMultipleFromSelectSummarizedProps(props) {
-  const multipleDirectiveIndex = props.findIndex(
-    (prop) => prop.key.replace(/"/g, `'`) === "'multiple'"
-  );
-  const multipleAttributeIndex = props.findIndex((prop) => prop.key === "multiple");
-  if (multipleDirectiveIndex === -1 && multipleAttributeIndex === -1) {
-    return "false";
-  }
-  const priorityIndex = multipleDirectiveIndex >= 0 ? multipleDirectiveIndex : multipleAttributeIndex;
-  const value = props[priorityIndex]?.value;
-  return typeof value === "string" ? value.replace(/'|"/g, "") : value ?? "true";
-}
-const RECURSABLE_NODE_TYPES$1 = /* @__PURE__ */ new Set([
-  compilerCore.NodeTypes.ELEMENT,
-  compilerCore.NodeTypes.FOR,
-  compilerCore.NodeTypes.IF,
-  compilerCore.NodeTypes.IF_BRANCH
-]);
-const NATIVE_FORM_TAGS = /* @__PURE__ */ new Set([
-  "input",
-  "textarea",
-  "select",
-  "option",
-  "form",
-  "fieldset",
-  "label",
-  "button"
-]);
-function inferOptionValueFromChildren(node) {
-  if (!("children" in node)) return null;
-  const children = node.children;
-  if (children.length !== 1) return null;
-  const only = children[0];
-  if (only === void 0) return null;
-  if (typeof only === "string" || typeof only === "symbol") return null;
-  if (only.type !== compilerCore.NodeTypes.TEXT) return null;
-  const text = only.content.trim();
-  return JSON.stringify(text);
-}
-const componentBridgeTransform = (node, context) => {
-  const snapshots = [];
-  const snapshotProps = (target) => {
-    if (snapshots.some((entry) => entry.target === target)) return;
-    snapshots.push({ target, snapshot: [...target] });
-  };
-  try {
-    let traverseSelectNode = function(_node, previousOptionExpressions2) {
-      const isOption = _node.type === compilerCore.NodeTypes.ELEMENT && _node.tag === "option";
-      if (!isOption) {
-        if (!RECURSABLE_NODE_TYPES$1.has(_node.type)) return;
-        const hasChildren = "children" in _node;
-        if (!hasChildren) return;
-        for (const child of _node.children) {
-          if (typeof child === "symbol" || typeof child === "string") continue;
-          if (child.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION) continue;
-          traverseSelectNode(child, previousOptionExpressions2);
-        }
-        return;
-      }
-      hasSlottedOptions = true;
-      const optionProps = getSummarizedProps(_node);
-      const valueIndex = optionProps.findIndex((p) => isExactKey(p.key, "value"));
-      let optionValueSummarizedProp;
-      if (valueIndex >= 0 && valueIndex < optionProps.length) {
-        optionValueSummarizedProp = optionProps[valueIndex];
-      } else {
-        const fallback = inferOptionValueFromChildren(_node);
-        if (fallback === null) {
-          return;
-        }
-        optionValueSummarizedProp = { key: "value", value: fallback };
-      }
-      const props = _node.props;
-      snapshotProps(props);
-      removePropsByName(props, ["selected"]);
-      const newProp = {
-        arg: compilerCore.createSimpleExpression("selected", true),
-        exp: compilerCore.createCompoundExpression(
-          generateEqualityExpression$1(
-            registerSummarizedProp?.value ?? "undefined",
-            optionValueSummarizedProp?.value ?? "undefined",
-            previousOptionExpressions2
-          )
-        ),
-        name: "bind",
-        modifiers: [],
-        type: compilerCore.NodeTypes.DIRECTIVE,
-        loc: _node.loc
-      };
-      props.push(newProp);
-    };
-    const isSelect = node.type === compilerCore.NodeTypes.ELEMENT && node.tag === "select";
-    const isCustomComponent = node.type === compilerCore.NodeTypes.ELEMENT && node.tagType === compilerCore.ElementTypes.COMPONENT;
-    const isKebabCustomElement = node.type === compilerCore.NodeTypes.ELEMENT && node.tagType === compilerCore.ElementTypes.ELEMENT && node.tag.includes("-") && !NATIVE_FORM_TAGS.has(node.tag);
-    if (!(isSelect || isCustomComponent || isKebabCustomElement)) return;
-    const selectSummarizedProps = getSummarizedProps(node);
-    const registerIndex = selectSummarizedProps.findIndex((p) => isExactKey(p.key, "register"));
-    if (selectSummarizedProps.length === 0 || registerIndex < 0 || registerIndex >= selectSummarizedProps.length)
-      return;
-    const registerSummarizedProp = selectSummarizedProps[registerIndex];
-    const selectLoc = node.loc;
-    let hasSlottedOptions = false;
-    const multipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps);
-    const previousOptionExpressions = typeof multipleExpression === "string" ? [[multipleExpression]] : [multipleExpression];
-    for (const child of node.children) {
-      traverseSelectNode(child, previousOptionExpressions);
-    }
-    const isStaticallyNonMultiple = multipleExpression === "false";
-    const isComponentHost = isCustomComponent || isKebabCustomElement;
-    const isSelectLikeHost = isSelect || isComponentHost && hasSlottedOptions;
-    const isPlainComponentHost = isComponentHost && !hasSlottedOptions;
-    const selectProps = node.props;
-    snapshotProps(selectProps);
-    removePropsByName(selectProps, ["value"]);
-    if (isStaticallyNonMultiple && isSelectLikeHost) {
-      const valuePropExpArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
-      const initExpression = compilerCore.createCompoundExpression([
-        "(",
-        ...valuePropExpArray,
-        ")?.displayValue.value"
-      ]);
-      const simpleExpression = compilerCore.createSimpleExpression(flattenExpression(initExpression), false);
-      let outputExp;
-      try {
-        outputExp = compilerCore.processExpression(simpleExpression, { ...context, prefixIdentifiers: false });
-      } catch (err) {
-        console.error(
-          "[attaform] component-bridge transform: processExpression failed; falling back to the unprocessed expression.",
-          err
-        );
-        outputExp = simpleExpression;
-      }
-      const valueProp = {
-        rawName: ":value",
-        arg: compilerCore.createSimpleExpression("value", true),
-        exp: outputExp,
-        name: "bind",
-        modifiers: [],
-        type: compilerCore.NodeTypes.DIRECTIVE,
-        loc: selectLoc
-      };
-      node.props.push(valueProp);
-    }
-    if (isPlainComponentHost) {
-      removePropsByName(node.props, [
-        "model",
-        "modelValue",
-        "onUpdate:modelValue",
-        "update:modelValue"
-      ]);
-      const modelValuePropExpArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
-      const modelInitExpression = compilerCore.createCompoundExpression([
-        "(",
-        ...modelValuePropExpArray,
-        ")?.hostModelValue?.value"
-      ]);
-      const modelSimpleExpression = compilerCore.createSimpleExpression(
-        flattenExpression(modelInitExpression),
-        false
-      );
-      let modelOutputExp;
-      try {
-        modelOutputExp = compilerCore.processExpression(modelSimpleExpression, {
-          ...context,
-          prefixIdentifiers: false
-        });
-      } catch (err) {
-        console.error(
-          "[attaform] component-bridge transform: processExpression failed for :modelValue; falling back to the unprocessed expression.",
-          err
-        );
-        modelOutputExp = modelSimpleExpression;
-      }
-      const modelValueProp = {
-        rawName: ":modelValue",
-        arg: compilerCore.createSimpleExpression("modelValue", true),
-        exp: modelOutputExp,
-        name: "bind",
-        modifiers: [],
-        type: compilerCore.NodeTypes.DIRECTIVE,
-        loc: selectLoc
-      };
-      node.props.push(modelValueProp);
-      const updateInitExpression = compilerCore.createCompoundExpression([
-        "$event => (",
-        ...modelValuePropExpArray,
-        ")?.setValueFromHost?.($event)"
-      ]);
-      const updateSimpleExpression = compilerCore.createSimpleExpression(
-        flattenExpression(updateInitExpression),
-        false
-      );
-      let updateOutputExp;
-      try {
-        updateOutputExp = compilerCore.processExpression(updateSimpleExpression, {
-          ...context,
-          prefixIdentifiers: false
-        });
-      } catch (err) {
-        console.error(
-          "[attaform] component-bridge transform: processExpression failed for onUpdate:modelValue; falling back to the unprocessed expression.",
-          err
-        );
-        updateOutputExp = updateSimpleExpression;
-      }
-      const updateModelValueProp = {
-        rawName: "@update:modelValue",
-        arg: compilerCore.createSimpleExpression("onUpdate:modelValue", true),
-        exp: updateOutputExp,
-        name: "bind",
-        modifiers: [],
-        type: compilerCore.NodeTypes.DIRECTIVE,
-        loc: selectLoc
-      };
-      node.props.push(updateModelValueProp);
-    }
-    const registerExprArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
-    const hasAuthorDisabled = selectSummarizedProps.findIndex((p) => isExactKey(p.key, "disabled")) !== -1;
-    if (!hasAuthorDisabled) {
-      const disabledInitExpression = compilerCore.createCompoundExpression([
-        "(",
-        ...registerExprArray,
-        ")?.disabled?.value"
-      ]);
-      const disabledSimpleExpression = compilerCore.createSimpleExpression(
-        flattenExpression(disabledInitExpression),
-        false
-      );
-      let disabledOutputExp;
-      try {
-        disabledOutputExp = compilerCore.processExpression(disabledSimpleExpression, {
-          ...context,
-          prefixIdentifiers: false
-        });
-      } catch (err) {
-        console.error(
-          "[attaform] component-bridge transform: processExpression failed for :disabled; falling back to the unprocessed expression.",
-          err
-        );
-        disabledOutputExp = disabledSimpleExpression;
-      }
-      const disabledProp = {
-        rawName: ":disabled",
-        arg: compilerCore.createSimpleExpression("disabled", true),
-        exp: disabledOutputExp,
-        name: "bind",
-        modifiers: [],
-        type: compilerCore.NodeTypes.DIRECTIVE,
-        loc: selectLoc
-      };
-      node.props.push(disabledProp);
-    }
-    if (isSelect) {
-      return;
-    }
-    const registerProps = node.props.filter(
-      (x) => x.type === compilerCore.NodeTypes.DIRECTIVE && x.name === "register"
-    );
-    const registerProp = registerProps[0];
-    if (!registerProp) return;
-    const alreadyInjected = node.props.some(
-      (p) => p.type === compilerCore.NodeTypes.DIRECTIVE && p.name === "bind" && p.arg !== void 0 && "content" in p.arg && p.arg.content === "registerValue"
-    );
-    if (alreadyInjected) return;
-    if (registerProp.type === compilerCore.NodeTypes.DIRECTIVE && !registerProp.modifiers.some(
-      (m) => m.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION && m.content === registerProtocol.SSR_COMPONENT_HOST_MODIFIER
-    )) {
-      registerProp.modifiers.push(compilerCore.createSimpleExpression(registerProtocol.SSR_COMPONENT_HOST_MODIFIER, true));
-    }
-    const customElementProp = {
-      arg: compilerCore.createSimpleExpression("registerValue", true),
-      exp: "exp" in registerProp ? registerProp.exp : compilerCore.createSimpleExpression("undefined", false),
-      name: "bind",
-      modifiers: [],
-      type: compilerCore.NodeTypes.DIRECTIVE,
-      loc: selectLoc
-    };
-    node.props.push(customElementProp);
-  } catch (err) {
-    for (const { target, snapshot } of snapshots.slice().reverse()) {
-      target.splice(0, target.length, ...snapshot);
-    }
-    console.error("[attaform] component-bridge transform failed, skipping:", err);
-  }
-};
-
-function generateEqualityExpression(registerValue, optionValue, scalarTarget) {
-  const registerValueArr = Array.isArray(registerValue) ? registerValue : [registerValue];
-  const optionValueArr = Array.isArray(optionValue) ? optionValue : [optionValue];
-  const scalarTargetArr = Array.isArray(scalarTarget) ? scalarTarget : [scalarTarget];
-  return [
-    "Array.isArray((",
-    ...registerValueArr,
-    ")?.innerRef?.value) ? ",
-    "(",
-    ...registerValueArr,
-    ")?.innerRef?.value?.includes(",
-    ...optionValueArr,
-    ") : ",
-    "(",
-    ...registerValueArr,
-    ")?.innerRef?.value instanceof Set ? (",
-    ...registerValueArr,
-    ")?.innerRef?.value?.has(",
-    ...optionValueArr,
-    ") : ",
-    "(typeof (",
-    ...registerValueArr,
-    ")?.innerRef?.value !== 'object' && String((",
-    ...registerValueArr,
-    ")?.innerRef?.value) === String((",
-    ...scalarTargetArr,
-    ")))"
-  ];
-}
-function parseStaticStringLiteral(text) {
-  const literalMatch = /^(["'`])(.*)\1$/.exec(text.trim());
-  if (literalMatch === null) return null;
-  return { quote: literalMatch[1], inner: literalMatch[2] };
-}
-function isStaticTypeOneOf(value, names) {
-  if (Array.isArray(value)) return false;
-  const parsed = parseStaticStringLiteral(value);
-  if (parsed === null) return false;
-  return names.includes(parsed.inner.toLowerCase());
-}
-function isDynamicTypeValue(value) {
-  if (Array.isArray(value)) return true;
-  return parseStaticStringLiteral(value) === null;
-}
-const inputTextAreaNodeTransform = (node) => {
-  try {
-    let computeProps = function(_node, registerSummarizedProp2, elementValueSummarizedProp2) {
-      const injectedLoc = _node.loc;
-      const props = _node.props;
-      const isStaticCheckbox = typeProp !== void 0 && isStaticTypeOneOf(typeProp.value, ["checkbox"]);
-      const isStaticRadio = typeProp !== void 0 && isStaticTypeOneOf(typeProp.value, ["radio"]);
-      const isDynamicType = typeProp !== void 0 && isDynamicTypeValue(typeProp.value);
-      const keepStaticValue = isStaticCheckbox || isStaticRadio || isDynamicType;
-      removePropsByName(props, keepStaticValue ? ["checked"] : ["checked", "value"]);
-      const registerValueArr = Array.isArray(registerSummarizedProp2.value) ? registerSummarizedProp2.value : [registerSummarizedProp2.value];
-      const valueExpression = compilerCore.createCompoundExpression([
-        "(",
-        ...registerValueArr,
-        ")?.displayValue?.value"
-      ]);
-      const trueValueIndex = elementProps.findIndex((p) => isExactKey(p.key, "true-value"));
-      const trueValueProp = elementProps[trueValueIndex];
-      const scalarTarget = isStaticCheckbox ? trueValueProp !== void 0 ? trueValueProp.value : "true" : elementValueSummarizedProp2.value;
-      const coreExpression = [
-        "(",
-        ...elementSelectionLabelExpression.children,
-        ") === 'checked' ? (",
-        // resolves to a boolean
-        ...generateEqualityExpression(
-          registerSummarizedProp2.value,
-          elementValueSummarizedProp2.value,
-          scalarTarget
-        ),
-        ") : (",
-        // resolves to the provided register value
-        ...valueExpression.children,
-        ")"
-      ];
-      const exp = isDynamicType ? compilerCore.createCompoundExpression([
-        "String((",
-        ...inputTypeExpressionArray,
-        ")).toLowerCase() === 'file' ? undefined : (",
-        ...coreExpression,
-        ")"
-      ]) : compilerCore.createCompoundExpression(coreExpression);
-      const valueOrCheckedProp = {
-        // reconstruct the `value` attribute based on the provided v-registerer, now that the computation is complete
-        arg: elementSelectionLabelExpression,
-        exp,
-        name: "bind",
-        modifiers: [],
-        type: compilerCore.NodeTypes.DIRECTIVE,
-        loc: injectedLoc
-      };
-      props.push(valueOrCheckedProp);
-      const hasAuthorDisabled = elementProps.findIndex((p) => isExactKey(p.key, "disabled")) !== -1;
-      if (!hasAuthorDisabled) {
-        const disabledProp = {
-          arg: compilerCore.createSimpleExpression("disabled", true, injectedLoc),
-          exp: compilerCore.createCompoundExpression(["(", ...registerValueArr, ")?.disabled?.value"]),
-          name: "bind",
-          modifiers: [],
-          type: compilerCore.NodeTypes.DIRECTIVE,
-          loc: injectedLoc
-        };
-        props.push(disabledProp);
-      }
-    };
-    if (node.type !== compilerCore.NodeTypes.ELEMENT) return;
-    const isInput = node.tag === "input";
-    const isTextArea = node.tag === "textarea";
-    if (!isInput && !isTextArea) return;
-    const elementProps = getSummarizedProps(node);
-    const registerIndex = elementProps.findIndex((p) => isExactKey(p.key, "register"));
-    const registerSummarizedProp = elementProps[registerIndex];
-    if (!registerSummarizedProp) return;
-    const typeIndex = elementProps.findIndex((p) => isExactKey(p.key, "type"));
-    const typeProp = elementProps[typeIndex];
-    if (typeProp !== void 0 && isStaticTypeOneOf(typeProp.value, ["file"])) return;
-    const valueIndex = elementProps.findIndex((p) => isExactKey(p.key, "value"));
-    const elementValueSummarizedProp = elementProps?.[valueIndex] ?? {
-      key: "value",
-      value: "''"
-    };
-    const inputTypeIndex = typeIndex;
-    const defaultSummarizedTextProp = { key: "type", value: "'text'" };
-    const inputTypeSummarizedProp = inputTypeIndex === -1 ? defaultSummarizedTextProp : elementProps[inputTypeIndex] ?? defaultSummarizedTextProp;
-    const inputTypeExpressionArray = typeof inputTypeSummarizedProp.value === "string" ? [inputTypeSummarizedProp.value] : inputTypeSummarizedProp.value;
-    const elementSelectionLabelExpression = compilerCore.createCompoundExpression([
-      "(",
-      "String((",
-      ...inputTypeExpressionArray,
-      ")).toLowerCase()",
-      " === 'checkbox' || ",
-      "String((",
-      ...inputTypeExpressionArray,
-      ")).toLowerCase() === 'radio'",
-      ") ? 'checked' : 'value'"
-    ]);
-    computeProps(node, registerSummarizedProp, elementValueSummarizedProp);
-  } catch (err) {
-    console.error("[attaform] input/textarea transform failed, skipping:", err);
-  }
-};
-
-const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
-  compilerCore.NodeTypes.ELEMENT,
-  compilerCore.NodeTypes.FOR,
-  compilerCore.NodeTypes.IF,
-  compilerCore.NodeTypes.IF_BRANCH
-]);
-function findRedundantStateBinding(props, stateNames) {
-  for (const prop of props) {
-    if (prop.type === compilerCore.NodeTypes.ATTRIBUTE) {
-      if (stateNames.includes(prop.name)) return prop.name;
-      continue;
-    }
-    if (prop.name === "model") return "v-model";
-    if (prop.name === "bind" && prop.arg?.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic && stateNames.includes(prop.arg.content)) {
-      return `:${prop.arg.content}`;
-    }
-  }
-  return null;
-}
-function classifyInput(props) {
-  let staticType = null;
-  for (const prop of props) {
-    if (prop.type === compilerCore.NodeTypes.ATTRIBUTE) {
-      if (prop.name === "type") staticType = prop.value?.content ?? null;
-      continue;
-    }
-    if (prop.name === "bind" && prop.arg?.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic && prop.arg.content === "type") {
-      return "dynamic";
-    }
-  }
-  if (staticType === "checkbox") return "checkbox";
-  if (staticType === "radio") return "radio";
-  if (staticType === "file") return "file";
-  return "text";
-}
-function emitRedundantWarning(tag, binding) {
-  console.warn(
-    `[attaform] \`${binding}\` is redundant beside v-register on <${tag}>. v-register already drives this field's value, so keep v-register alone and drop \`${binding}\`. (An identity \`:value\` on a radio or <option> is expected and stays silent.)`
-  );
-}
-function walkOptionsForSelected(selectNode) {
-  const visit = (candidate) => {
-    if (candidate.type === compilerCore.NodeTypes.ELEMENT && candidate.tag === "option") {
-      const found = findRedundantStateBinding(candidate.props, ["selected"]);
-      if (found !== null) emitRedundantWarning("option", found);
-      return;
-    }
-    if (!RECURSABLE_NODE_TYPES.has(candidate.type)) return;
-    if (!("children" in candidate)) return;
-    for (const child of candidate.children) {
-      if (typeof child === "string" || typeof child === "symbol") continue;
-      if (child.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION) continue;
-      visit(child);
-    }
-  };
-  for (const child of selectNode.children) visit(child);
-}
-function warnIfRedundant(node) {
-  if (node.tagType !== compilerCore.ElementTypes.ELEMENT) return;
-  const tag = node.tag;
-  if (tag === "select") {
-    const found2 = findRedundantStateBinding(node.props, ["value"]);
-    if (found2 !== null) emitRedundantWarning("select", found2);
-    walkOptionsForSelected(node);
-    return;
-  }
-  if (tag === "textarea") {
-    const found2 = findRedundantStateBinding(node.props, ["value"]);
-    if (found2 !== null) emitRedundantWarning("textarea", found2);
-    return;
-  }
-  if (tag !== "input") return;
-  const kind = classifyInput(node.props);
-  if (kind === "dynamic" || kind === "file") return;
-  const stateNames = kind === "checkbox" || kind === "radio" ? ["checked"] : ["value"];
-  const found = findRedundantStateBinding(node.props, stateNames);
-  if (found !== null) emitRedundantWarning("input", found);
-}
-const redundantBindingWarnTransform = (node) => {
-  try {
-    if (node.type !== compilerCore.NodeTypes.ELEMENT) return;
-    const registerProp = node.props.find(
-      (prop) => prop.type === compilerCore.NodeTypes.DIRECTIVE && prop.name === "register"
-    );
-    if (registerProp === void 0) return;
-    const alreadyProcessed = registerProp.modifiers.some(
-      (modifier) => modifier.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION && modifier.content === registerProtocol.V_REGISTER_COMPILED_MODIFIER
-    );
-    if (alreadyProcessed) return;
-    warnIfRedundant(node);
-    registerProp.modifiers.push(compilerCore.createSimpleExpression(registerProtocol.V_REGISTER_COMPILED_MODIFIER, true));
-  } catch (err) {
-    console.error("[attaform] redundant-binding warn transform failed, skipping:", err);
-  }
-};
-
-const HINT_MARKER = "__attaRv";
-const HINT_PREFIX = `((${HINT_MARKER}) => (${HINT_MARKER}?.markConnectedOptimistically?.(), ${HINT_MARKER}))(`;
-const HINT_SUFFIX = `)`;
-const vRegisterHintTransform = (node) => {
-  try {
-    if (node.type !== compilerCore.NodeTypes.ELEMENT) return;
-    for (const prop of node.props) {
-      if (prop.type !== compilerCore.NodeTypes.DIRECTIVE) continue;
-      if (prop.name !== "register") continue;
-      if (prop.exp === void 0) continue;
-      if (isAlreadyWrapped(prop.exp)) continue;
-      prop.exp = wrapWithOptimisticHint(prop.exp);
-    }
-  } catch (err) {
-    console.error("[attaform] v-register hint transform failed, skipping:", err);
-  }
-};
-function isAlreadyWrapped(exp) {
-  if (exp.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION) {
-    return exp.content.includes(HINT_MARKER);
-  }
-  for (const child of exp.children) {
-    if (typeof child === "string" && child.includes(HINT_MARKER)) return true;
-  }
-  return false;
-}
-function wrapWithOptimisticHint(exp) {
-  const innerChildren = exp.type === compilerCore.NodeTypes.SIMPLE_EXPRESSION ? [exp] : [...exp.children];
-  return compilerCore.createCompoundExpression([HINT_PREFIX, ...innerChildren, HINT_SUFFIX], exp.loc);
-}
-
-const stateByRoot = /* @__PURE__ */ new WeakMap();
-const PREAMBLE_ATTR = "data-atta-pre-mark";
-const vRegisterPreambleTransform = (node, context) => {
-  try {
-    if (node.type === compilerCore.NodeTypes.ROOT) {
-      if (stateByRoot.has(node)) return;
-      stateByRoot.set(node, {
-        captured: [],
-        capturedElements: /* @__PURE__ */ new WeakSet(),
-        vForDepth: 0,
-        firstRootElementVisited: false
-      });
-      return () => {
-        stateByRoot.delete(node);
-      };
-    }
-    const state = stateByRoot.get(context.root);
-    if (state === void 0) return;
-    if (node.type === compilerCore.NodeTypes.FOR) {
-      state.vForDepth += 1;
-      return () => {
-        state.vForDepth -= 1;
-      };
-    }
-    if (node.type !== compilerCore.NodeTypes.ELEMENT) return;
-    captureVRegisterIfStatic(node, state);
-    if (!state.firstRootElementVisited && context.parent?.type === compilerCore.NodeTypes.ROOT) {
-      state.firstRootElementVisited = true;
-      return () => {
-        const finalState = stateByRoot.get(context.root);
-        if (finalState === void 0 || finalState.captured.length === 0) return;
-        injectPreamble(node, finalState.captured);
-      };
-    }
-    return;
-  } catch (err) {
-    console.error("[attaform] v-register preamble transform failed, skipping:", err);
-    return;
-  }
-};
-function captureVRegisterIfStatic(node, state) {
-  if (state.vForDepth > 0) return;
-  if (hasVForDirective(node)) return;
-  if (state.capturedElements.has(node)) return;
-  const exp = findVRegisterExpression(node);
-  if (exp === null) return;
-  state.capturedElements.add(node);
-  state.captured.push(flattenExpression(exp));
-}
-function findVRegisterExpression(node) {
-  for (const prop of node.props) {
-    if (prop.type !== compilerCore.NodeTypes.DIRECTIVE) continue;
-    if (prop.name !== "register") continue;
-    if (prop.exp === void 0) continue;
-    return prop.exp;
-  }
-  return null;
-}
-function hasVForDirective(node) {
-  for (const prop of node.props) {
-    if (prop.type === compilerCore.NodeTypes.DIRECTIVE && prop.name === "for") return true;
-  }
-  return false;
-}
-function injectPreamble(element, captured) {
-  if (hasPreamble(element)) return;
-  const callList = captured.map((source) => `(()=>{try{(${source})?.markConnectedOptimistically?.()}catch{}})()`).join(", ");
-  const expressionText = `(${callList}, undefined)`;
-  const exp = compilerCore.createSimpleExpression(
-    expressionText,
-    false
-    /* not static */
-  );
-  const directive = {
-    type: compilerCore.NodeTypes.DIRECTIVE,
-    name: "bind",
-    arg: compilerCore.createSimpleExpression(
-      PREAMBLE_ATTR,
-      true
-      /* static arg */
-    ),
-    exp,
-    modifiers: [],
-    // Reuse the host element's source location so any runtime error
-    // in the synthesized expression points at the consumer's template
-    // line, not at the dummyLoc that pre-fix was line 0.
-    loc: element.loc
-  };
-  element.props.unshift(directive);
-}
-function hasPreamble(element) {
-  for (const prop of element.props) {
-    if (prop.type !== compilerCore.NodeTypes.DIRECTIVE) continue;
-    if (prop.name !== "bind") continue;
-    if (prop.arg === void 0) continue;
-    if (prop.arg.type !== compilerCore.NodeTypes.SIMPLE_EXPRESSION) continue;
-    if (prop.arg.content === PREAMBLE_ATTR) return true;
-  }
-  return false;
-}
-
-exports.componentBridgeTransform = componentBridgeTransform;
-exports.inputTextAreaNodeTransform = inputTextAreaNodeTransform;
-exports.redundantBindingWarnTransform = redundantBindingWarnTransform;
-exports.vRegisterHintTransform = vRegisterHintTransform;
-exports.vRegisterPreambleTransform = vRegisterPreambleTransform;
-//# sourceMappingURL=attaform.Bn0IzhD_.cjs.map