attaform 0.0.1 → 0.14.0

package/dist/shared/attaform.CXpzmj38.mjs

@@ -0,0 +1,617 @@
+import { createCompoundExpression, NodeTypes, createSimpleExpression, ElementTypes, processExpression } from '@vue/compiler-core';
+
+function getSummarizedProps$1(node) {
+  if (!("props" in node)) return [];
+  const props = node.props;
+  const summarizedProps = props.reduce((acc, currProp) => {
+    if (currProp.type === NodeTypes.ATTRIBUTE) {
+      const key2 = currProp.name;
+      const value2 = currProp.value?.content ?? "";
+      return [...acc, { key: key2, value: renderAsStatic$1(value2, true) }];
+    }
+    if (currProp.exp === void 0) return acc;
+    const key = currProp.arg ? getSummarizedPropValue$1(currProp.arg) : renderAsStatic$1(currProp.name, true);
+    if (typeof key !== "string") return acc;
+    const value = getSummarizedPropValue$1(currProp.exp);
+    return [...acc, { key, value }];
+  }, []);
+  return summarizedProps;
+}
+function renderAsStatic$1(val, isStatic) {
+  return isStatic ? `"${val}"` : val;
+}
+function getSummarizedPropValue$1(exp) {
+  if (exp.type === NodeTypes.SIMPLE_EXPRESSION) {
+    return renderAsStatic$1(exp.content, exp.isStatic);
+  }
+  return exp.children;
+}
+function generateEqualityExpression$1(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,
+    ") : ",
+    "((",
+    ...registerValueArr,
+    ")?.innerRef?.value === (",
+    ...scalarTargetArr,
+    "))"
+  ];
+}
+function removePropsByName$1(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$1(summarizedKey, name) {
+  return summarizedKey === name || summarizedKey === `"${name}"`;
+}
+function isStaticTypeOneOf(value, names) {
+  if (Array.isArray(value)) return false;
+  const trimmed = value.trim();
+  const literalMatch = /^(["'`])(.*)\1$/.exec(trimmed);
+  if (literalMatch === null) return false;
+  const inner = literalMatch[2].toLowerCase();
+  return names.includes(inner);
+}
+function couldResolveToFileType(value) {
+  if (Array.isArray(value)) return true;
+  const trimmed = value.trim();
+  const literalMatch = /^(["'`])(.*)\1$/.exec(trimmed);
+  if (literalMatch === null) return true;
+  const quote = literalMatch[1];
+  const inner = literalMatch[2];
+  if (quote === "`" && inner.includes("${")) return true;
+  return inner.toLowerCase() === "file";
+}
+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 keepStaticValue = isStaticCheckbox || isStaticRadio;
+      removePropsByName$1(props, keepStaticValue ? ["checked"] : ["checked", "value"]);
+      const registerValueArr = Array.isArray(registerSummarizedProp2.value) ? registerSummarizedProp2.value : [registerSummarizedProp2.value];
+      const valueExpression = createCompoundExpression([
+        "(",
+        ...registerValueArr,
+        ")?.displayValue?.value"
+      ]);
+      const trueValueIndex = elementProps.findIndex((p) => isExactKey$1(p.key, "true-value"));
+      const trueValueProp = elementProps[trueValueIndex];
+      const scalarTarget = isStaticCheckbox ? trueValueProp !== void 0 ? trueValueProp.value : "true" : elementValueSummarizedProp2.value;
+      const valueOrCheckedProp = {
+        // reconstruct the `value` attribute based on the provided v-registerer, now that the computation is complete
+        arg: elementSelectionLabelExpression,
+        exp: createCompoundExpression([
+          "(",
+          ...elementSelectionLabelExpression.children,
+          ") === 'checked' ? (",
+          // resolves to a boolean
+          ...generateEqualityExpression$1(
+            registerSummarizedProp2.value,
+            elementValueSummarizedProp2.value,
+            scalarTarget
+          ),
+          ") : (",
+          // resolves to the provided register value
+          ...valueExpression.children,
+          ")"
+        ]),
+        name: "bind",
+        modifiers: [],
+        type: NodeTypes.DIRECTIVE,
+        loc: injectedLoc
+      };
+      props.push(valueOrCheckedProp);
+    };
+    if (node.type !== NodeTypes.ELEMENT) return;
+    const isInput = node.tag === "input";
+    const isTextArea = node.tag === "textarea";
+    if (!isInput && !isTextArea) return;
+    const elementProps = getSummarizedProps$1(node);
+    const registerIndex = elementProps.findIndex((p) => isExactKey$1(p.key, "register"));
+    const registerSummarizedProp = elementProps[registerIndex];
+    if (!registerSummarizedProp) return;
+    const typeIndex = elementProps.findIndex((p) => isExactKey$1(p.key, "type"));
+    const typeProp = elementProps[typeIndex];
+    if (typeProp !== void 0 && couldResolveToFileType(typeProp.value)) return;
+    const valueIndex = elementProps.findIndex((p) => isExactKey$1(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 = 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);
+  }
+};
+
+function getSummarizedProps(node) {
+  if (!("props" in node)) return [];
+  const props = node.props;
+  const summarizedProps = props.reduce((acc, currProp) => {
+    if (currProp.type === 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 === NodeTypes.SIMPLE_EXPRESSION) {
+    return renderAsStatic(exp.content, exp.isStatic);
+  }
+  return exp.children;
+}
+function generateEqualityExpression(selectValue, optionValue, previousOptionExpressions) {
+  function getExpressionNodeChildren(_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,
+      `))))`
+    ];
+  }
+  return getExpressionNodeChildren(selectValue, optionValue, previousOptionExpressions);
+}
+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";
+}
+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 flattenCompoundExpression(node) {
+  let result = "";
+  for (const child of node.children) {
+    if (typeof child === "string") {
+      result += child;
+    } else if (typeof child === "symbol") {
+      continue;
+    } else if (child.type === NodeTypes.SIMPLE_EXPRESSION) {
+      result += child.content;
+    } else if (child.type === NodeTypes.COMPOUND_EXPRESSION) {
+      result += flattenCompoundExpression(child);
+    }
+  }
+  return result;
+}
+function isExactKey(summarizedKey, name) {
+  return summarizedKey === name || summarizedKey === `"${name}"`;
+}
+const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
+  NodeTypes.ELEMENT,
+  NodeTypes.FOR,
+  NodeTypes.IF,
+  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 !== NodeTypes.TEXT) return null;
+  const text = only.content.trim();
+  return JSON.stringify(text);
+}
+const selectNodeTransform = (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 === NodeTypes.ELEMENT && _node.tag === "option";
+      if (!isOption) {
+        if (!RECURSABLE_NODE_TYPES.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 === NodeTypes.SIMPLE_EXPRESSION) continue;
+          traverseSelectNode(child, previousOptionExpressions2);
+        }
+        return;
+      }
+      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: createSimpleExpression("selected", true),
+        exp: createCompoundExpression(
+          generateEqualityExpression(
+            registerSummarizedProp?.value ?? "undefined",
+            optionValueSummarizedProp?.value ?? "undefined",
+            previousOptionExpressions2
+          )
+        ),
+        name: "bind",
+        modifiers: [],
+        type: NodeTypes.DIRECTIVE,
+        loc: _node.loc
+      };
+      props.push(newProp);
+    };
+    const isSelect = node.type === NodeTypes.ELEMENT && node.tag === "select";
+    const isCustomComponent = node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.COMPONENT;
+    const isKebabCustomElement = node.type === NodeTypes.ELEMENT && node.tagType === 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;
+    const multipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps);
+    const previousOptionExpressions = typeof multipleExpression === "string" ? [[multipleExpression]] : [multipleExpression];
+    const isStaticallyNonMultiple = multipleExpression === "false";
+    const selectProps = node.props;
+    snapshotProps(selectProps);
+    removePropsByName(selectProps, ["value"]);
+    if (isStaticallyNonMultiple) {
+      const valuePropExpArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
+      const initExpression = createCompoundExpression([
+        "(",
+        ...valuePropExpArray,
+        ")?.displayValue.value"
+      ]);
+      const simpleExpression = createSimpleExpression(
+        flattenCompoundExpression(initExpression),
+        false
+      );
+      let outputExp;
+      try {
+        outputExp = processExpression(simpleExpression, { ...context, prefixIdentifiers: false });
+      } catch (err) {
+        console.error(
+          "[attaform] select transform: processExpression failed; falling back to the unprocessed expression.",
+          err
+        );
+        outputExp = simpleExpression;
+      }
+      const valueProp = {
+        rawName: ":value",
+        arg: createSimpleExpression("value", true),
+        exp: outputExp,
+        name: "bind",
+        modifiers: [],
+        type: NodeTypes.DIRECTIVE,
+        loc: selectLoc
+      };
+      node.props.push(valueProp);
+    }
+    if (isSelect) {
+      for (const child of node.children) {
+        traverseSelectNode(child, previousOptionExpressions);
+      }
+      return;
+    }
+    const registerProps = node.props.filter(
+      (x) => x.type === NodeTypes.DIRECTIVE && x.name === "register"
+    );
+    const registerProp = registerProps[0];
+    if (!registerProp) return;
+    const alreadyInjected = node.props.some(
+      (p) => p.type === NodeTypes.DIRECTIVE && p.name === "bind" && p.arg !== void 0 && "content" in p.arg && p.arg.content === "registerValue"
+    );
+    if (alreadyInjected) return;
+    const customElementProp = {
+      arg: createSimpleExpression("registerValue", true),
+      exp: "exp" in registerProp ? registerProp.exp : createSimpleExpression("undefined", false),
+      name: "bind",
+      modifiers: [],
+      type: 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] select 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 !== NodeTypes.ELEMENT) return;
+    for (const prop of node.props) {
+      if (prop.type !== 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 === 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 === NodeTypes.SIMPLE_EXPRESSION ? [exp] : [...exp.children];
+  return 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 === 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 === NodeTypes.FOR) {
+      state.vForDepth += 1;
+      return () => {
+        state.vForDepth -= 1;
+      };
+    }
+    if (node.type !== NodeTypes.ELEMENT) return;
+    captureVRegisterIfStatic(node, state);
+    if (!state.firstRootElementVisited && context.parent?.type === 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 !== 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 === NodeTypes.DIRECTIVE && prop.name === "for") return true;
+  }
+  return false;
+}
+function flattenExpression(exp) {
+  if (exp.type === 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;
+    if ("content" in child) {
+      out += child.content;
+      continue;
+    }
+    out += flattenExpression(child);
+  }
+  return out;
+}
+function injectPreamble(element, captured) {
+  if (hasPreamble(element)) return;
+  const callList = captured.map((source) => `(()=>{try{(${source})?.markConnectedOptimistically?.()}catch{}})()`).join(", ");
+  const expressionText = `(${callList}, undefined)`;
+  const exp = createSimpleExpression(
+    expressionText,
+    false
+    /* not static */
+  );
+  const directive = {
+    type: NodeTypes.DIRECTIVE,
+    name: "bind",
+    arg: 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 !== NodeTypes.DIRECTIVE) continue;
+    if (prop.name !== "bind") continue;
+    if (prop.arg === void 0) continue;
+    if (prop.arg.type !== NodeTypes.SIMPLE_EXPRESSION) continue;
+    if (prop.arg.content === PREAMBLE_ATTR) return true;
+  }
+  return false;
+}
+
+export { vRegisterPreambleTransform as a, inputTextAreaNodeTransform as i, selectNodeTransform as s, vRegisterHintTransform as v };
+//# sourceMappingURL=attaform.CXpzmj38.mjs.map