svelte-origin 1.0.0-next.22 → 1.0.0-next.24

package/dist/index.js

@@ -3473,34 +3473,22 @@ function __attrsFor(factory, rawAttrs) {
   const factoryWithSchema = factory;
   const schema = getMergedAttrSchema(factoryWithSchema);
   const wrapper = {};
-  const localValues = {};
-  const hasLocalValue = {};
   const defineExposedProp = (key2, info) => {
     if (Object.prototype.hasOwnProperty.call(wrapper, key2))
       return;
-    const base = {
+    const descriptor = {
       get() {
-        if (hasLocalValue[key2])
-          return localValues[key2];
         return rawAttrs[key2];
       },
       enumerable: true,
       configurable: true
     };
     if (info.bindable) {
-      Object.defineProperty(wrapper, key2, {
-        ...base,
-        set(value) {
-          localValues[key2] = value;
-          hasLocalValue[key2] = true;
-          try {
-            rawAttrs[key2] = value;
-          } catch {}
-        }
-      });
-    } else {
-      Object.defineProperty(wrapper, key2, base);
+      descriptor.set = function(value) {
+        rawAttrs[key2] = value;
+      };
     }
+    Object.defineProperty(wrapper, key2, descriptor);
   };
   for (const [key2, info] of Object.entries(schema)) {
     const parentValue = rawAttrs[key2];
@@ -3521,8 +3509,6 @@ function __attrsFor(factory, rawAttrs) {
   return new Proxy(wrapper, {
     get(target, prop2) {
       if (typeof prop2 === "string" && prop2 in schema) {
-        if (hasLocalValue[prop2])
-          return localValues[prop2];
         return rawAttrs[prop2];
       }
       if (prop2 in target)
@@ -3531,15 +3517,11 @@ function __attrsFor(factory, rawAttrs) {
     },
     set(target, prop2, value) {
       if (typeof prop2 === "string" && prop2 in schema) {
-        localValues[prop2] = value;
-        hasLocalValue[prop2] = true;
         if (!Object.prototype.hasOwnProperty.call(wrapper, prop2)) {
           defineExposedProp(prop2, schema[prop2]);
         }
         if (schema[prop2].bindable) {
-          try {
-            rawAttrs[prop2] = value;
-          } catch {}
+          rawAttrs[prop2] = value;
         }
         return true;
       }
@@ -3551,18 +3533,10 @@ function __attrsFor(factory, rawAttrs) {
       }
       try {
         rawAttrs[prop2] = value;
-      } catch {
-        if (typeof prop2 === "string") {
-          localValues[prop2] = value;
-          hasLocalValue[prop2] = true;
-        }
-      }
+      } catch {}
       return true;
     },
     has(target, prop2) {
-      if (typeof prop2 === "string" && prop2 in schema) {
-        return prop2 in target || hasLocalValue[prop2];
-      }
       return prop2 in target || prop2 in rawAttrs;
     },
     ownKeys() {
@@ -3889,6 +3863,79 @@ function findMatchingBracket(source2, openIndex, openChar = "(", closeChar = ")"
   return -1;
 }
 
+// src/transform/reserved-keywords.ts
+var RESERVED_KEYWORDS = new Set([
+  "break",
+  "case",
+  "catch",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "in",
+  "instanceof",
+  "new",
+  "return",
+  "switch",
+  "this",
+  "throw",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "class",
+  "const",
+  "enum",
+  "export",
+  "extends",
+  "import",
+  "super",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield",
+  "await",
+  "async",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "arguments",
+  "eval"
+]);
+function getInternalVarName(propName, forcePrefix = true) {
+  return `___${propName}`;
+}
+function generatePropDestructure(propName, defaultValue) {
+  const internalName = getInternalVarName(propName);
+  return `${propName}: ${internalName} = ${defaultValue}`;
+}
+function generatePropDestructureNoDefault(propName) {
+  const internalName = getInternalVarName(propName);
+  return `${propName}: ${internalName}`;
+}
+function generateGetter(propName) {
+  const internalName = getInternalVarName(propName);
+  return `get ${propName}() { return ${internalName} }`;
+}
+function generateSetter(propName) {
+  const internalName = getInternalVarName(propName);
+  return `set ${propName}(v) { ${internalName} = v }`;
+}
+
 // src/transform/schema.ts
 function parseOriginSchemaFromSource(source2, exportName) {
   const sourceResult = parseSourceOrigin(source2, exportName);
@@ -4227,14 +4274,14 @@ function generatePropsDestructuring(attrs, factoryName) {
   for (const attr2 of attrs) {
     if (attr2.bindable) {
       if (attr2.hasDefault) {
-        parts.push(`${attr2.key} = $bindable(${attr2.defaultValue})`);
+        parts.push(generatePropDestructure(attr2.key, `$bindable(${attr2.defaultValue})`));
       } else {
-        parts.push(`${attr2.key} = $bindable()`);
+        parts.push(generatePropDestructure(attr2.key, "$bindable()"));
       }
     } else if (attr2.hasDefault) {
-      parts.push(`${attr2.key} = ${attr2.defaultValue}`);
+      parts.push(generatePropDestructure(attr2.key, attr2.defaultValue));
     } else {
-      parts.push(attr2.key);
+      parts.push(generatePropDestructureNoDefault(attr2.key));
     }
   }
   return `let { ${parts.join(", ")} }: $attrs.Of<typeof ${factoryName}> = $props()`;
@@ -4242,9 +4289,9 @@ function generatePropsDestructuring(attrs, factoryName) {
 function generateFactoryCallFromAttrs(factoryName, attrs) {
   const parts = [];
   for (const attr2 of attrs) {
-    parts.push(`get ${attr2.key}() { return ${attr2.key} }`);
+    parts.push(generateGetter(attr2.key));
     if (attr2.bindable) {
-      parts.push(`set ${attr2.key}(v) { ${attr2.key} = v }`);
+      parts.push(generateSetter(attr2.key));
     }
   }
   return `${factoryName}({ ${parts.join(", ")} })`;
@@ -6563,7 +6610,10 @@ function transformAttrsOriginCallsSync(s, source2, neededImports) {
   let firstFactoryExpr = null;
   let propsTypeDeclaration = null;
   let isFirstDeclaration = true;
-  const needsPropsInjection = declarations.length > 0 && !hasExistingPropsDeclaration(source2);
+  const originInstances = new Map;
+  const existingPropsMatch = source2.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  const hasExistingProps = !!existingPropsMatch;
+  const needsPropsInjection = declarations.length > 0 && !hasExistingPropsDeclaration(source2) && !hasExistingProps;
   for (const decl of declarations) {
     const { varName, startIndex, macroOpenParen } = decl;
     const closeParenIndex = findMatchingBracket(source2, macroOpenParen);
@@ -6584,20 +6634,47 @@ function transformAttrsOriginCallsSync(s, source2, neededImports) {
       expansionLines.push(`type $$Props = $attrs.Of<${typeExpr}>`);
       propsTypeDeclaration = "";
     }
-    expansionLines.push(`let ___attrs: $$Props = $props()`, `let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ___attrs))`);
+    if (hasExistingProps) {
+      const existingContent = existingPropsMatch[1];
+      const hasRestSpread = /\.\.\.\s*(\w+)\s*$/.test(existingContent);
+      if (!hasRestSpread && isFirstDeclaration) {
+        const restVarName = "___originAttrs";
+        const newContent = existingContent.trimEnd() ? `${existingContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+        const braceEnd = source2.indexOf("}", existingPropsMatch.index + 5);
+        if (braceEnd !== -1) {
+          s.overwrite(existingPropsMatch.index + 5, braceEnd, ` ${newContent} `);
+        }
+        expansionLines.push(`let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ${restVarName}))`);
+      } else {
+        const restMatch = existingContent.match(/\.\.\.\s*(\w+)\s*$/);
+        const restVar = restMatch ? restMatch[1] : "___originAttrs";
+        expansionLines.push(`let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ${restVar}))`);
+      }
+    } else {
+      expansionLines.push(`let ___attrs: $$Props = $props()`, `let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ___attrs))`);
+    }
     s.overwrite(startIndex, endIndex, expansionLines.join(`
 `));
+    originInstances.set(varName, {
+      varName,
+      factoryExpr,
+      startPos: startIndex,
+      endPos: endIndex
+    });
     neededImports.add("__attrsFor");
     changed = true;
     isFirstDeclaration = false;
   }
-  return { changed, propsTypeDeclaration };
+  return { changed, propsTypeDeclaration, originInstances };
 }
 async function transformAttrsOriginCalls(s, source2, neededImports, schemaResolver) {
   const declarations = findVariableDeclarationsWithMacro(source2, "$attrs.origin");
   let changed = false;
   let propsTypeDeclaration = null;
-  const needsPropsInjection = declarations.length > 0 && !hasExistingPropsDeclaration(source2);
+  const originInstances = new Map;
+  const existingPropsMatch = source2.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  const hasExistingProps = !!existingPropsMatch;
+  const needsPropsInjection = declarations.length > 0 && !hasExistingPropsDeclaration(source2) && !hasExistingProps;
   const matches = [];
   for (const decl of declarations) {
     const { varName, startIndex, macroOpenParen } = decl;
@@ -6617,6 +6694,7 @@ async function transformAttrsOriginCalls(s, source2, neededImports, schemaResolv
   }
   let firstFactoryExpr = null;
   let isFirstDeclaration = true;
+  let restVarInjected = false;
   for (const { varName, factoryExpr, startIndex, endIndex, isGeneric } of matches) {
     const expansionLines = [];
     let usesFallback = true;
@@ -6644,15 +6722,40 @@ async function transformAttrsOriginCalls(s, source2, neededImports, schemaResolv
     }
     if (usesFallback) {
       const normalizedFactoryCall = normalizeFactoryCall(factoryExpr);
-      expansionLines.push(`let ___attrs: $$Props = $props()`, `let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ___attrs))`);
+      if (hasExistingProps) {
+        const existingContent = existingPropsMatch[1];
+        const hasRestSpread = /\.\.\.\s*(\w+)\s*$/.test(existingContent);
+        if (!hasRestSpread && !restVarInjected) {
+          const restVarName = "___originAttrs";
+          const newContent = existingContent.trimEnd() ? `${existingContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source2.indexOf("}", existingPropsMatch.index + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsMatch.index + 5, braceEnd, ` ${newContent} `);
+            restVarInjected = true;
+          }
+          expansionLines.push(`let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ${restVarName}))`);
+        } else {
+          const restMatch = existingContent.match(/\.\.\.\s*(\w+)\s*$/);
+          const restVar = restMatch ? restMatch[1] : "___originAttrs";
+          expansionLines.push(`let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ${restVar}))`);
+        }
+      } else {
+        expansionLines.push(`let ___attrs: $$Props = $props()`, `let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ___attrs))`);
+      }
       neededImports.add("__attrsFor");
     }
     s.overwrite(startIndex, endIndex, expansionLines.join(`
 `));
+    originInstances.set(varName, {
+      varName,
+      factoryExpr,
+      startPos: startIndex,
+      endPos: endIndex
+    });
     changed = true;
     isFirstDeclaration = false;
   }
-  return { changed, propsTypeDeclaration };
+  return { changed, propsTypeDeclaration, originInstances };
 }
 
 // src/transform/element-types.ts
@@ -6661,7 +6764,34 @@ function getElementTypeImport(element2) {
 }
 
 // src/transform/attrs-for-transform.ts
-function transformAttrsForCalls(s, source2, neededImports) {
+function generateReactiveAttrsWrapper(attrs) {
+  const parts = [];
+  for (const attr2 of attrs) {
+    parts.push(generateGetter(attr2.key));
+    if (attr2.bindable) {
+      parts.push(generateSetter(attr2.key));
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function generateAttrsForMerge(attrs) {
+  const parts = [];
+  for (const attr2 of attrs) {
+    if (attr2.bindable) {
+      if (attr2.hasDefault) {
+        parts.push(generatePropDestructure(attr2.key, `$bindable(${attr2.defaultValue})`));
+      } else {
+        parts.push(generatePropDestructure(attr2.key, "$bindable()"));
+      }
+    } else if (attr2.hasDefault) {
+      parts.push(generatePropDestructure(attr2.key, attr2.defaultValue));
+    } else {
+      parts.push(generatePropDestructureNoDefault(attr2.key));
+    }
+  }
+  return parts.join(", ");
+}
+function transformAttrsForCallsSync(s, source2, neededImports) {
   let changed = false;
   const existingPropsMatch = source2.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
   let restVarName = null;
@@ -6727,6 +6857,396 @@ function transformAttrsForCalls(s, source2, neededImports) {
   }
   return changed;
 }
+async function transformAttrsForCalls(s, source2, neededImports, schemaResolver) {
+  let changed = false;
+  const existingPropsMatch = source2.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  let restVarName = null;
+  let existingPropsStart = -1;
+  let existingDestructureContent = "";
+  if (existingPropsMatch) {
+    existingPropsStart = existingPropsMatch.index;
+    existingDestructureContent = existingPropsMatch[1];
+    const restMatch = existingDestructureContent.match(/\.\.\.\s*(\w+)\s*$/);
+    if (restMatch) {
+      restVarName = restMatch[1];
+    }
+  }
+  const declarations = findVariableDeclarationsWithMacro(source2, "$attrs.for");
+  for (const decl of declarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source2, macroOpenParen);
+    if (closeParenIndex === -1)
+      continue;
+    const arg = source2.slice(macroOpenParen + 1, closeParenIndex).trim();
+    const endIndex = closeParenIndex + 1;
+    const stringMatch = arg.match(/^['"](\w+)['"]$/);
+    if (stringMatch) {
+      const element2 = stringMatch[1];
+      const typeImport = getElementTypeImport(element2);
+      if (existingPropsMatch && existingPropsStart !== -1) {
+        if (!restVarName) {
+          restVarName = "___restAttrs";
+          const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source2.indexOf("}", existingPropsStart + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+          }
+        }
+        s.overwrite(startIndex, endIndex, `let ${varName} = ${restVarName} as ${typeImport}`);
+      } else {
+        const expansion = `let { ...${varName} } = $props<${typeImport}>()`;
+        s.overwrite(startIndex, endIndex, expansion);
+      }
+    } else {
+      const factoryName = arg;
+      let transformed = false;
+      if (schemaResolver) {
+        const importPath = findImportPath(source2, factoryName);
+        if (importPath) {
+          const schema = await schemaResolver.resolve(importPath, factoryName);
+          if (schema && schema.attrs.length > 0) {
+            if (existingPropsMatch && existingPropsStart !== -1) {
+              const additionalAttrs = generateAttrsForMerge(schema.attrs);
+              const restMatch = existingDestructureContent.match(/,?\s*\.\.\.\s*(\w+)\s*$/);
+              let baseContent = existingDestructureContent;
+              let restPart = "";
+              if (restMatch) {
+                restPart = restMatch[0];
+                baseContent = existingDestructureContent.slice(0, restMatch.index);
+              }
+              const mergedDestructure = baseContent.trimEnd() ? `${baseContent.trimEnd()}, ${additionalAttrs}${restPart}` : `${additionalAttrs}${restPart}`;
+              const braceEnd = source2.indexOf("}", existingPropsStart + 5);
+              if (braceEnd !== -1) {
+                s.overwrite(existingPropsStart + 5, braceEnd, ` ${mergedDestructure} `);
+              }
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`);
+              transformed = true;
+            } else {
+              const propsDestructure = generatePropsDestructuring(schema.attrs, factoryName);
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              const expansion = [
+                propsDestructure,
+                `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`
+              ].join(`
+`);
+              s.overwrite(startIndex, endIndex, expansion);
+              transformed = true;
+            }
+          }
+        }
+      }
+      if (!transformed) {
+        if (existingPropsMatch && existingPropsStart !== -1) {
+          if (!restVarName) {
+            restVarName = "___restAttrs";
+            const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+            const braceEnd = source2.indexOf("}", existingPropsStart + 5);
+            if (braceEnd !== -1) {
+              s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+            }
+          }
+          s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${restVarName})`);
+        } else {
+          const expansion = [
+            `let ___attrs: $attrs.Of<typeof ${factoryName}> = $props()`,
+            `let ${varName} = __attrsFor(${factoryName}, ___attrs)`
+          ].join(`
+`);
+          s.overwrite(startIndex, endIndex, expansion);
+        }
+      }
+      neededImports.add("__attrsFor");
+    }
+    changed = true;
+  }
+  return changed;
+}
+
+// src/transform/origin-destructure-transform.ts
+function transformOriginDestructuring(s, source2, originInstances) {
+  let changed = false;
+  const destructures = findOriginDestructures(source2, originInstances);
+  for (const d of destructures.reverse()) {
+    const replacement = generateDestructureReplacement(d, originInstances);
+    if (replacement) {
+      s.overwrite(d.startPos, d.endPos, replacement);
+      changed = true;
+    }
+  }
+  return changed;
+}
+function findOriginDestructures(source2, originInstances) {
+  const results = [];
+  const destructurePattern = /\b(let|const|var)\s*\{/g;
+  let match;
+  while ((match = destructurePattern.exec(source2)) !== null) {
+    if (isInsideStringOrComment(source2, match.index))
+      continue;
+    const declKeyword = match[1];
+    const braceStart = match.index + match[0].length - 1;
+    const braceEnd = findMatchingBracket(source2, braceStart, "{", "}");
+    if (braceEnd === -1)
+      continue;
+    let i = braceEnd + 1;
+    while (i < source2.length && /\s/.test(source2[i]))
+      i++;
+    if (source2[i] !== "=")
+      continue;
+    i++;
+    while (i < source2.length && /\s/.test(source2[i]))
+      i++;
+    const exprStart = i;
+    let sourceVar = "";
+    while (i < source2.length && /[\w$]/.test(source2[i])) {
+      sourceVar += source2[i];
+      i++;
+    }
+    if (!sourceVar)
+      continue;
+    if (!originInstances.has(sourceVar))
+      continue;
+    let isPropsAccess = false;
+    const afterVarPos = i;
+    while (i < source2.length && /\s/.test(source2[i]))
+      i++;
+    if (source2[i] === ".") {
+      i++;
+      while (i < source2.length && /\s/.test(source2[i]))
+        i++;
+      const propName = readIdentifier(source2, i);
+      if (propName === "props") {
+        isPropsAccess = true;
+        i += propName.length;
+      } else {
+        continue;
+      }
+    }
+    let endPos = i;
+    while (endPos < source2.length && /\s/.test(source2[endPos]) && source2[endPos] !== `
+`)
+      endPos++;
+    if (source2[endPos] === ";")
+      endPos++;
+    if (source2[endPos] === `
+`)
+      endPos++;
+    const patternContent = source2.slice(braceStart + 1, braceEnd);
+    const parsed = parseDestructurePattern(patternContent, isPropsAccess);
+    results.push({
+      startPos: match.index,
+      endPos,
+      sourceVar,
+      isPropsAccess,
+      methods: parsed.methods,
+      props: parsed.props,
+      nestedPropsPattern: parsed.nestedProps
+    });
+  }
+  return results;
+}
+function parseDestructurePattern(content, isPropsAccess) {
+  const methods = [];
+  const props = [];
+  let nestedProps = null;
+  const parts = splitByTopLevelCommas2(content);
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed)
+      continue;
+    const propsMatch = trimmed.match(/^props\s*:\s*\{/);
+    if (propsMatch) {
+      const braceStart = trimmed.indexOf("{");
+      const braceEnd = findMatchingBracket(trimmed, braceStart, "{", "}");
+      if (braceEnd !== -1) {
+        const nestedContent = trimmed.slice(braceStart + 1, braceEnd);
+        const nestedParts = splitByTopLevelCommas2(nestedContent);
+        const nestedPropsList = [];
+        for (const np of nestedParts) {
+          const parsed = parseDestructuredProp(np.trim());
+          if (parsed)
+            nestedPropsList.push(parsed);
+        }
+        nestedProps = {
+          startPos: 0,
+          endPos: 0,
+          props: nestedPropsList
+        };
+      }
+      continue;
+    }
+    if (isPropsAccess) {
+      const parsed = parseDestructuredProp(trimmed);
+      if (parsed)
+        props.push(parsed);
+    } else {
+      const parsed = parseDestructuredItem(trimmed);
+      if (parsed)
+        methods.push(parsed);
+    }
+  }
+  return { methods, props, nestedProps };
+}
+function parseDestructuredItem(part) {
+  const trimmed = part.trim();
+  if (!trimmed)
+    return null;
+  const colonIdx = findTopLevelColon(trimmed);
+  let key2;
+  let alias = null;
+  let rest = trimmed;
+  if (colonIdx !== -1) {
+    key2 = trimmed.slice(0, colonIdx).trim();
+    rest = trimmed.slice(colonIdx + 1).trim();
+    const eqIdx2 = findTopLevelEquals(rest);
+    if (eqIdx2 !== -1) {
+      alias = rest.slice(0, eqIdx2).trim();
+      return {
+        key: key2,
+        alias,
+        defaultValue: rest.slice(eqIdx2 + 1).trim()
+      };
+    } else {
+      alias = rest;
+      return { key: key2, alias, defaultValue: null };
+    }
+  }
+  const eqIdx = findTopLevelEquals(trimmed);
+  if (eqIdx !== -1) {
+    key2 = trimmed.slice(0, eqIdx).trim();
+    return {
+      key: key2,
+      alias: null,
+      defaultValue: trimmed.slice(eqIdx + 1).trim()
+    };
+  }
+  return { key: trimmed, alias: null, defaultValue: null };
+}
+function parseDestructuredProp(part) {
+  const item = parseDestructuredItem(part);
+  if (!item)
+    return null;
+  let isBindable2 = false;
+  let bindableDefault = null;
+  if (item.defaultValue) {
+    const bindableMatch = item.defaultValue.match(/^\$bindable\s*\(/);
+    if (bindableMatch) {
+      isBindable2 = true;
+      const parenStart = item.defaultValue.indexOf("(");
+      const parenEnd = findMatchingBracket(item.defaultValue, parenStart, "(", ")");
+      if (parenEnd !== -1) {
+        bindableDefault = item.defaultValue.slice(parenStart + 1, parenEnd).trim() || null;
+      }
+    }
+  }
+  return {
+    ...item,
+    isBindable: isBindable2,
+    bindableDefault
+  };
+}
+function generateDestructureReplacement(d, originInstances) {
+  const lines = [];
+  const instance = originInstances.get(d.sourceVar);
+  if (!instance)
+    return null;
+  for (const m of d.methods) {
+    const varName = m.alias || m.key;
+    if (m.defaultValue) {
+      lines.push(`let ${varName} = ${d.sourceVar}.${m.key}?.bind(${d.sourceVar}) ?? ${m.defaultValue}`);
+    } else {
+      lines.push(`let ${varName} = ${d.sourceVar}.${m.key}.bind(${d.sourceVar})`);
+    }
+  }
+  if (d.nestedPropsPattern) {
+    for (const p of d.nestedPropsPattern.props) {
+      lines.push(...generatePropAccessors(p, d.sourceVar));
+    }
+  }
+  if (d.isPropsAccess) {
+    for (const p of d.props) {
+      lines.push(...generatePropAccessors(p, d.sourceVar));
+    }
+  }
+  return lines.join(`
+`) + `
+`;
+}
+function generatePropAccessors(p, sourceVar) {
+  const lines = [];
+  const varName = p.alias || p.key;
+  if (p.isBindable) {
+    const defaultVal = p.bindableDefault || "undefined";
+    lines.push(`let ${varName} = $derived(${sourceVar}.props.${p.key} ?? ${defaultVal})`);
+  } else if (p.defaultValue) {
+    lines.push(`let ${varName} = $derived(${sourceVar}.props.${p.key} ?? ${p.defaultValue})`);
+  } else {
+    lines.push(`let ${varName} = $derived(${sourceVar}.props.${p.key})`);
+  }
+  return lines;
+}
+function splitByTopLevelCommas2(content) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (let i = 0;i < content.length; i++) {
+    const char = content[i];
+    if (char === "{" || char === "(" || char === "[" || char === "<") {
+      depth++;
+      current += char;
+    } else if (char === "}" || char === ")" || char === "]" || char === ">") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  return parts;
+}
+function findTopLevelColon(str) {
+  let depth = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str[i];
+    if (char === "{" || char === "(" || char === "[" || char === "<")
+      depth++;
+    else if (char === "}" || char === ")" || char === "]" || char === ">")
+      depth--;
+    else if (char === ":" && depth === 0)
+      return i;
+  }
+  return -1;
+}
+function findTopLevelEquals(str) {
+  let depth = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str[i];
+    if (char === "{" || char === "(" || char === "[" || char === "<")
+      depth++;
+    else if (char === "}" || char === ")" || char === "]" || char === ">")
+      depth--;
+    else if (char === "=" && depth === 0) {
+      if (str[i + 1] !== "=" && str[i + 1] !== ">") {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function readIdentifier(str, start) {
+  let result = "";
+  let i = start;
+  while (i < str.length && /[\w$]/.test(str[i])) {
+    result += str[i];
+    i++;
+  }
+  return result;
+}
 
 // src/transform/core.ts
 function transformScript(source2, options = {}) {
@@ -6750,9 +7270,12 @@ function transformScript(source2, options = {}) {
     const result = transformAttrsOriginCallsSync(s, source2, neededImports);
     changed = result.changed || changed;
     propsTypeDeclaration = result.propsTypeDeclaration;
+    if (result.originInstances.size > 0) {
+      changed = transformOriginDestructuring(s, source2, result.originInstances) || changed;
+    }
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source2, neededImports) || changed;
+    changed = transformAttrsForCallsSync(s, source2, neededImports) || changed;
   }
   const needsPropsInjection = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjection)) {
@@ -6821,9 +7344,12 @@ async function transformScriptAsync(source2, options) {
     const result = await transformAttrsOriginCalls(s, source2, neededImports, schemaResolver);
     changed = result.changed || changed;
     propsTypeDeclaration = result.propsTypeDeclaration;
+    if (result.originInstances.size > 0) {
+      changed = transformOriginDestructuring(s, source2, result.originInstances) || changed;
+    }
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source2, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source2, neededImports, schemaResolver) || changed;
   }
   const needsPropsInjectionAsync = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjectionAsync)) {
@@ -6891,9 +7417,12 @@ async function transformScriptContent(source2, options) {
     const result = await transformAttrsOriginCalls(s, source2, neededImports, schemaResolver);
     changed = result.changed || changed;
     propsTypeDeclaration = result.propsTypeDeclaration;
+    if (result.originInstances.size > 0) {
+      changed = transformOriginDestructuring(s, source2, result.originInstances) || changed;
+    }
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source2, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source2, neededImports, schemaResolver) || changed;
   }
   if (neededImports.size > 0) {
     const importStatement = generateRuntimeImport([...neededImports]);