octane 0.2.11 → 0.2.13

package/dist/compiler/volar.js

@@ -51,14 +51,14 @@ var keywords$1 = {
 var keywordRelationalOperator = /^in(stanceof)?$/;
 var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
 var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-function isInAstralSet(code, set) {
+function isInAstralSet(code, set2) {
   var pos = 65536;
-  for (var i2 = 0; i2 < set.length; i2 += 2) {
-    pos += set[i2];
+  for (var i2 = 0; i2 < set2.length; i2 += 2) {
+    pos += set2[i2];
     if (pos > code) {
       return false;
     }
-    pos += set[i2 + 1];
+    pos += set2[i2 + 1];
     if (pos >= code) {
       return true;
     }
@@ -459,8 +459,8 @@ var SCOPE_CLASS_STATIC_BLOCK = 256;
 var SCOPE_CLASS_FIELD_INIT = 512;
 var SCOPE_SWITCH = 1024;
 var SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION | SCOPE_CLASS_STATIC_BLOCK;
-function functionFlags(async, generator) {
-  return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0);
+function functionFlags(async2, generator) {
+  return SCOPE_FUNCTION | (async2 ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0);
 }
 var BIND_NONE = 0;
 var BIND_VAR = 1;
@@ -1504,29 +1504,29 @@ pp$8.parseClassElementName = function(element) {
     this.parsePropertyName(element);
   }
 };
-pp$8.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
-  var key2 = method.key;
-  if (method.kind === "constructor") {
+pp$8.parseClassMethod = function(method2, isGenerator, isAsync, allowsDirectSuper) {
+  var key2 = method2.key;
+  if (method2.kind === "constructor") {
     if (isGenerator) {
       this.raise(key2.start, "Constructor can't be a generator");
     }
     if (isAsync) {
       this.raise(key2.start, "Constructor can't be an async method");
     }
-  } else if (method.static && checkKeyName(method, "prototype")) {
+  } else if (method2.static && checkKeyName(method2, "prototype")) {
     this.raise(key2.start, "Classes may not have a static property named prototype");
   }
-  var value = method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
-  if (method.kind === "get" && value.params.length !== 0) {
+  var value = method2.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+  if (method2.kind === "get" && value.params.length !== 0) {
     this.raiseRecoverable(value.start, "getter should have no params");
   }
-  if (method.kind === "set" && value.params.length !== 1) {
+  if (method2.kind === "set" && value.params.length !== 1) {
     this.raiseRecoverable(value.start, "setter should have exactly one param");
   }
-  if (method.kind === "set" && value.params[0].type === "RestElement") {
+  if (method2.kind === "set" && value.params[0].type === "RestElement") {
     this.raiseRecoverable(value.params[0].start, "Setter cannot use rest params");
   }
-  return this.finishNode(method, "MethodDefinition");
+  return this.finishNode(method2, "MethodDefinition");
 };
 pp$8.parseClassField = function(field) {
   if (checkKeyName(field, "constructor")) {
@@ -2043,9 +2043,9 @@ pp$7.parseBindingList = function(close, allowEmpty, allowTrailingComma, allowMod
     } else if (allowTrailingComma && this.afterTrailingComma(close)) {
       break;
     } else if (this.type === types$1.ellipsis) {
-      var rest = this.parseRestBinding();
-      this.parseBindingListItem(rest);
-      elts.push(rest);
+      var rest2 = this.parseRestBinding();
+      this.parseBindingListItem(rest2);
+      elts.push(rest2);
       if (this.type === types$1.comma) {
         this.raiseRecoverable(this.start, "Comma is not permitted after the rest element");
       }
@@ -2212,11 +2212,11 @@ pp$6.inGeneratorContext = function() {
   return false;
 };
 pp$6.updateContext = function(prevType) {
-  var update, type = this.type;
+  var update2, type = this.type;
   if (type.keyword && prevType === types$1.dot) {
     this.exprAllowed = false;
-  } else if (update = type.updateContext) {
-    update.call(this, prevType);
+  } else if (update2 = type.updateContext) {
+    update2.call(this, prevType);
   } else {
     this.exprAllowed = type.beforeExpr;
   }
@@ -2493,13 +2493,13 @@ pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forIni
     expr = this.parseAwait(forInit);
     sawUnary = true;
   } else if (this.type.prefix) {
-    var node = this.startNode(), update = this.type === types$1.incDec;
+    var node = this.startNode(), update2 = this.type === types$1.incDec;
     node.operator = this.value;
     node.prefix = true;
     this.next();
-    node.argument = this.parseMaybeUnary(null, true, update, forInit);
+    node.argument = this.parseMaybeUnary(null, true, update2, forInit);
     this.checkExpressionErrors(refDestructuringErrors, true);
-    if (update) {
+    if (update2) {
       this.checkLValSimple(node.argument);
     } else if (this.strict && node.operator === "delete" && isLocalVariableAccess(node.argument)) {
       this.raiseRecoverable(node.start, "Deleting local variable in strict mode");
@@ -2508,7 +2508,7 @@ pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forIni
     } else {
       sawUnary = true;
     }
-    expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+    expr = this.finishNode(node, update2 ? "UpdateExpression" : "UnaryExpression");
   } else if (!sawUnary && this.type === types$1.privateId) {
     if ((forInit || this.privateNameStack.length === 0) && this.options.checkPrivateFields) {
       this.unexpected();
@@ -7167,8 +7167,8 @@ var acornScope = {
   BIND_FLAGS_CLASS: 128
   // function
 };
-function functionFlags2(async, generator) {
-  return acornScope.SCOPE_FUNCTION | (async ? acornScope.SCOPE_ASYNC : 0) | (generator ? acornScope.SCOPE_GENERATOR : 0);
+function functionFlags2(async2, generator) {
+  return acornScope.SCOPE_FUNCTION | (async2 ? acornScope.SCOPE_ASYNC : 0) | (generator ? acornScope.SCOPE_GENERATOR : 0);
 }
 function isPossiblyLiteralEnum(expression) {
   if (expression.type !== "MemberExpression") return false;
@@ -8439,7 +8439,7 @@ function tsPlugin(options) {
       tsParseTupleElementType() {
         const startLoc = this.startLoc;
         const startPos = this["start"];
-        const rest = this.eat(tt.ellipsis);
+        const rest2 = this.eat(tt.ellipsis);
         let type;
         if (this.tsIsTupleElementLabel()) {
           const labeledNode = this.startNode();
@@ -8460,7 +8460,7 @@ function tsPlugin(options) {
             type = this.finishNode(optionalTypeNode, "TSOptionalType");
           }
         }
-        if (rest) {
+        if (rest2) {
           const restNode = this.startNodeAt(startPos, startLoc);
           restNode.typeAnnotation = type;
           type = this.finishNode(restNode, "TSRestType");
@@ -8982,26 +8982,26 @@ function tsPlugin(options) {
           if (readonly) {
             this.raise(node.start, TypeScriptError.ReadonlyForMethodSignature);
           }
-          const method = nodeAny;
-          if (method.kind && this.tsMatchLeftRelational()) {
+          const method2 = nodeAny;
+          if (method2.kind && this.tsMatchLeftRelational()) {
             this.raise(this.start, TypeScriptError.AccesorCannotHaveTypeParameters);
           }
-          this.tsFillSignature(tt.colon, method);
+          this.tsFillSignature(tt.colon, method2);
           this.tsParseTypeMemberSemicolon();
           const paramsKey = "parameters";
           const returnTypeKey = "typeAnnotation";
-          if (method.kind === "get") {
-            if (method[paramsKey].length > 0) {
+          if (method2.kind === "get") {
+            if (method2[paramsKey].length > 0) {
               this.raise(this.start, "A 'get' accesor must not have any formal parameters.");
-              if (this.isThisParam(method[paramsKey][0])) {
+              if (this.isThisParam(method2[paramsKey][0])) {
                 this.raise(this.start, TypeScriptError.AccesorCannotDeclareThisParameter);
               }
             }
-          } else if (method.kind === "set") {
-            if (method[paramsKey].length !== 1) {
+          } else if (method2.kind === "set") {
+            if (method2[paramsKey].length !== 1) {
               this.raise(this.start, "A 'get' accesor must not have any formal parameters.");
             } else {
-              const firstParameter = method[paramsKey][0];
+              const firstParameter = method2[paramsKey][0];
               if (this.isThisParam(firstParameter)) {
                 this.raise(this.start, TypeScriptError.AccesorCannotDeclareThisParameter);
               }
@@ -9012,16 +9012,16 @@ function tsPlugin(options) {
                 this.raise(this.start, TypeScriptError.SetAccesorCannotHaveRestParameter);
               }
             }
-            if (method[returnTypeKey]) {
+            if (method2[returnTypeKey]) {
               this.raise(
-                method[returnTypeKey].start,
+                method2[returnTypeKey].start,
                 TypeScriptError.SetAccesorCannotHaveReturnType
               );
             }
           } else {
-            method.kind = "method";
+            method2.kind = "method";
           }
-          return this.finishNode(method, "TSMethodSignature");
+          return this.finishNode(method2, "TSMethodSignature");
         } else {
           const property = nodeAny;
           if (readonly) property.readonly = true;
@@ -9998,17 +9998,17 @@ function tsPlugin(options) {
         }
         return super.parseClassField(field);
       }
-      parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper) {
-        const isConstructor = method.kind === "constructor";
-        const isPrivate = method.key.type === "PrivateIdentifier";
+      parseClassMethod(method2, isGenerator, isAsync, allowsDirectSuper) {
+        const isConstructor = method2.kind === "constructor";
+        const isPrivate = method2.key.type === "PrivateIdentifier";
         const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
         if (isPrivate) {
-          if (typeParameters) method.typeParameters = typeParameters;
-          if (method.accessibility) {
+          if (typeParameters) method2.typeParameters = typeParameters;
+          if (method2.accessibility) {
             this.raise(
-              method.start,
+              method2.start,
               TypeScriptError.PrivateMethodsHasAccessibility({
-                modifier: method.accessibility
+                modifier: method2.accessibility
               })
             );
           }
@@ -10017,32 +10017,32 @@ function tsPlugin(options) {
             this.raise(typeParameters.start, TypeScriptError.ConstructorHasTypeParameters);
           }
         }
-        const { declare = false, kind } = method;
+        const { declare = false, kind } = method2;
         if (declare && (kind === "get" || kind === "set")) {
-          this.raise(method.start, TypeScriptError.DeclareAccessor({ kind }));
+          this.raise(method2.start, TypeScriptError.DeclareAccessor({ kind }));
         }
-        if (typeParameters) method.typeParameters = typeParameters;
-        const key2 = method.key;
-        if (method.kind === "constructor") {
+        if (typeParameters) method2.typeParameters = typeParameters;
+        const key2 = method2.key;
+        if (method2.kind === "constructor") {
           if (isGenerator) this.raise(key2.start, "Constructor can't be a generator");
           if (isAsync) this.raise(key2.start, "Constructor can't be an async method");
-        } else if (method.static && checkKeyName2(method, "prototype")) {
+        } else if (method2.static && checkKeyName2(method2, "prototype")) {
           this.raise(key2.start, "Classes may not have a static property named prototype");
         }
-        const value = method.value = this.parseMethod(
+        const value = method2.value = this.parseMethod(
           isGenerator,
           isAsync,
           allowsDirectSuper,
           true,
-          method
+          method2
         );
-        if (method.kind === "get" && value["params"].length !== 0)
+        if (method2.kind === "get" && value["params"].length !== 0)
           this.raiseRecoverable(value.start, "getter should have no params");
-        if (method.kind === "set" && value["params"].length !== 1)
+        if (method2.kind === "set" && value["params"].length !== 1)
           this.raiseRecoverable(value.start, "setter should have exactly one param");
-        if (method.kind === "set" && value["params"][0].type === "RestElement")
+        if (method2.kind === "set" && value["params"][0].type === "RestElement")
           this.raiseRecoverable(value["params"][0].start, "Setter cannot use rest params");
-        return this.finishNode(method, "MethodDefinition");
+        return this.finishNode(method2, "MethodDefinition");
       }
       isClassMethod() {
         return this.match(tt.relational);
@@ -11026,7 +11026,7 @@ function tsPlugin(options) {
         if (typeParameters) params.typeParameters = typeParameters;
         return params;
       }
-      parseMethod(isGenerator, isAsync, allowDirectSuper, inClassScope, method) {
+      parseMethod(isGenerator, isAsync, allowDirectSuper, inClassScope, method2) {
         let node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
         this.initFunction(node);
         if (this.ecmaVersion >= 6) node.generator = isGenerator;
@@ -11046,14 +11046,14 @@ function tsPlugin(options) {
         this.yieldPos = oldYieldPos;
         this.awaitPos = oldAwaitPos;
         this.awaitIdentPos = oldAwaitIdentPos;
-        if (method && method.abstract) {
+        if (method2 && method2.abstract) {
           const hasBody = !!node.body;
           if (hasBody) {
-            const { key: key2 } = method;
+            const { key: key2 } = method2;
             this.raise(
-              method.start,
+              method2.start,
               TypeScriptError.AbstractMethodHasImplementation({
-                methodName: key2.type === "Identifier" && !method.computed ? key2.name : `[${this.input.slice(key2.start, key2.end)}]`
+                methodName: key2.type === "Identifier" && !method2.computed ? key2.name : `[${this.input.slice(key2.start, key2.end)}]`
               })
             );
           }
@@ -11449,17 +11449,127 @@ function apply_mutations(node, mutations) {
   );
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/utils/patterns.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/utils/builders.js
+var builders_exports = {};
+__export(builders_exports, {
+  array: () => array,
+  array_pattern: () => array_pattern,
+  arrow: () => arrow,
+  assignment: () => assignment,
+  assignment_pattern: () => assignment_pattern,
+  assignment_prop: () => assignment_prop,
+  async: () => async,
+  await: () => await_builder,
+  binary: () => binary,
+  block: () => block,
+  break: () => break_statement,
+  break_statement: () => break_statement,
+  call: () => call,
+  catch_clause: () => catch_clause_builder,
+  catch_clause_builder: () => catch_clause_builder,
+  conditional: () => conditional,
+  const: () => const_builder,
+  continue: () => continue_statement,
+  continue_statement: () => continue_statement,
+  debugger: () => debugger_builder,
+  declaration: () => declaration,
+  declarator: () => declarator,
+  do_while: () => do_while,
+  empty: () => empty2,
+  export: () => export_builder,
+  export_builder: () => export_builder,
+  export_default: () => export_default,
+  export_specifier: () => export_specifier,
+  false: () => false_instance,
+  for: () => for_builder,
+  for_of: () => for_of,
+  function: () => function_builder,
+  function_declaration: () => function_declaration,
+  get: () => get,
+  id: () => id,
+  if: () => if_builder,
+  import_all: () => import_all,
+  import_declaration: () => import_declaration,
+  import_specifier: () => import_specifier,
+  imports: () => imports,
+  init: () => init,
+  jsx_attribute: () => jsx_attribute,
+  jsx_closing_element: () => jsx_closing_element,
+  jsx_element: () => jsx_element,
+  jsx_element_fresh: () => jsx_element_fresh,
+  jsx_expression_container: () => jsx_expression_container,
+  jsx_fragment: () => jsx_fragment,
+  jsx_id: () => jsx_id,
+  jsx_member: () => jsx_member,
+  jsx_opening_element: () => jsx_opening_element,
+  jsx_spread_attribute: () => jsx_spread_attribute,
+  jsx_text: () => jsx_text,
+  key: () => key,
+  labeled: () => labeled,
+  let: () => let_builder,
+  literal: () => literal2,
+  logical: () => logical,
+  maybe_call: () => maybe_call,
+  member: () => member,
+  member_id: () => member_id,
+  method: () => method,
+  new: () => new_builder,
+  null: () => null_instance,
+  object: () => object,
+  object_pattern: () => object_pattern,
+  parenthesized: () => parenthesized,
+  private_id: () => private_id,
+  prop: () => prop,
+  prop_def: () => prop_def,
+  quasi: () => quasi,
+  rest: () => rest,
+  return: () => return_builder,
+  sequence: () => sequence,
+  set: () => set,
+  set_location: () => set_location,
+  spread: () => spread,
+  stmt: () => stmt,
+  switch: () => switch_builder,
+  switch_builder: () => switch_builder,
+  switch_case: () => switch_case,
+  template: () => template,
+  this: () => this_instance,
+  throw_error: () => throw_error,
+  thunk: () => thunk,
+  true: () => true_instance,
+  try: () => try_builder,
+  try_builder: () => try_builder,
+  ts_as: () => ts_as,
+  ts_import_equals: () => ts_import_equals,
+  ts_intersection_type: () => ts_intersection_type,
+  ts_keyword_type: () => ts_keyword_type,
+  ts_literal_type: () => ts_literal_type,
+  ts_property_signature: () => ts_property_signature,
+  ts_qualified_name: () => ts_qualified_name,
+  ts_type_alias: () => ts_type_alias,
+  ts_type_annotation: () => ts_type_annotation,
+  ts_type_literal: () => ts_type_literal,
+  ts_type_parameter_instantiation: () => ts_type_parameter_instantiation,
+  ts_type_query: () => ts_type_query,
+  ts_type_reference: () => ts_type_reference,
+  unary: () => unary,
+  unthunk: () => unthunk,
+  update: () => update,
+  var: () => var_builder,
+  void0: () => void0
+});
+
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/utils/patterns.js
 var regex_not_whitespace = /[^ \t\r\n]/;
 var regex_newline_characters = /\n/g;
 var regex_is_valid_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/utils/sanitize_template_string.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/utils/sanitize_template_string.js
 function sanitize_template_string(str) {
   return (str ?? "").replace(/(`|\${|\\)/g, "\\$1");
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/utils/builders.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/utils/builders.js
 function set_location(node, loc_info, is_deep_copy = false) {
   if (loc_info) {
     node.start = loc_info.start;
@@ -11478,7 +11588,13 @@ function set_location(node, loc_info, is_deep_copy = false) {
 function array(elements = []) {
   return { type: "ArrayExpression", elements, metadata: { path: [] } };
 }
-function arrow(params, body, async = false, type_parameters, loc_info) {
+function array_pattern(elements) {
+  return { type: "ArrayPattern", elements, metadata: { path: [] } };
+}
+function assignment_pattern(left, right) {
+  return { type: "AssignmentPattern", left, right, metadata: { path: [] } };
+}
+function arrow(params, body, async2 = false, type_parameters, loc_info) {
   const node = (
     /** @type {AST.ArrowFunctionExpression} */
     {
@@ -11487,7 +11603,7 @@ function arrow(params, body, async = false, type_parameters, loc_info) {
       body,
       expression: body.type !== "BlockStatement",
       generator: false,
-      async,
+      async: async2,
       typeParameters: type_parameters,
       metadata: { path: [] }
     }
@@ -11497,6 +11613,12 @@ function arrow(params, body, async = false, type_parameters, loc_info) {
 function assignment(operator, left, right) {
   return { type: "AssignmentExpression", operator, left, right, metadata: { path: [] } };
 }
+function async(func) {
+  return { ...func, async: true };
+}
+function await_builder(argument) {
+  return { type: "AwaitExpression", argument, metadata: { path: [] } };
+}
 function binary(operator, left, right) {
   return { type: "BinaryExpression", operator, left, right, metadata: { path: [] } };
 }
@@ -11504,6 +11626,9 @@ function block(body, loc_info) {
   const node = { type: "BlockStatement", body, metadata: { path: [] } };
   return set_location(node, loc_info);
 }
+function labeled(name, body) {
+  return { type: "LabeledStatement", label: id(name), body, metadata: { path: [] } };
+}
 function call(callee, ...args) {
   if (typeof callee === "string") callee = id(callee);
   args = args.slice();
@@ -11531,6 +11656,18 @@ function call(callee, ...args) {
     metadata: { path: [] }
   };
 }
+function maybe_call(callee, ...args) {
+  const expression = (
+    /** @type {AST.SimpleCallExpression} */
+    call(callee, ...args)
+  );
+  expression.optional = true;
+  return {
+    type: "ChainExpression",
+    expression,
+    metadata: { path: [] }
+  };
+}
 function unary(operator, argument) {
   return { type: "UnaryExpression", argument, operator, prefix: true, metadata: { path: [] } };
 }
@@ -11552,7 +11689,34 @@ function declarator(pattern, init2) {
   if (typeof pattern === "string") pattern = id(pattern);
   return { type: "VariableDeclarator", id: pattern, init: init2, metadata: { path: [] } };
 }
-function function_declaration(id2, params, body, async = false, type_parameters) {
+var empty2 = {
+  type: "EmptyStatement",
+  metadata: { path: [] }
+};
+function export_default(declaration2) {
+  return { type: "ExportDefaultDeclaration", declaration: declaration2, metadata: { path: [] } };
+}
+function export_specifier(local, exported = local, exportKind = "value") {
+  return {
+    type: "ExportSpecifier",
+    local: typeof local === "string" ? id(local) : local,
+    exported: typeof exported === "string" ? id(exported) : exported,
+    exportKind,
+    metadata: { path: [] }
+  };
+}
+function export_builder(declaration2, specifiers = [], attributes = [], exportKind = "value", source = null) {
+  return {
+    type: "ExportNamedDeclaration",
+    declaration: declaration2,
+    specifiers,
+    attributes,
+    exportKind,
+    source,
+    metadata: { path: [] }
+  };
+}
+function function_declaration(id2, params, body, async2 = false, type_parameters) {
   return {
     type: "FunctionDeclaration",
     id: id2,
@@ -11560,10 +11724,16 @@ function function_declaration(id2, params, body, async = false, type_parameters)
     params,
     body,
     generator: false,
-    async,
+    async: async2,
     metadata: { path: [] }
   };
 }
+function get(name, body) {
+  return (
+    /** @type {AST.Property & { value: AST.FunctionExpression}} */
+    prop("get", key(name), function_builder(null, [], block(body)))
+  );
+}
 function id(name, loc_info) {
   const node = {
     type: "Identifier",
@@ -11574,6 +11744,16 @@ function id(name, loc_info) {
   };
   return set_location(node, loc_info);
 }
+function private_id(name) {
+  return { type: "PrivateIdentifier", name, metadata: { path: [] } };
+}
+function import_namespace(local) {
+  return {
+    type: "ImportNamespaceSpecifier",
+    local: id(local),
+    metadata: { path: [] }
+  };
+}
 function init(name, value) {
   return prop("init", key(name), value);
 }
@@ -11598,6 +11778,18 @@ function member(object3, property, computed = false, optional = false, loc_info)
   };
   return set_location(node, loc_info);
 }
+function ts_as(expression, type_annotation, loc_info) {
+  const node = (
+    /** @type {AST.TSAsExpression} */
+    {
+      type: "TSAsExpression",
+      expression,
+      typeAnnotation: type_annotation,
+      metadata: { path: [] }
+    }
+  );
+  return set_location(node, loc_info);
+}
 function parenthesized(expression, loc_info) {
   const node = (
     /** @type {AST.ParenthesizedExpression} */
@@ -11644,6 +11836,28 @@ function ts_type_reference(type_name, type_arguments = null, loc_info) {
   );
   return set_location(node, loc_info);
 }
+function ts_literal_type(literal_node, loc_info) {
+  const node = (
+    /** @type {AST.TSLiteralType} */
+    {
+      type: "TSLiteralType",
+      literal: literal_node,
+      metadata: { path: [] }
+    }
+  );
+  return set_location(node, loc_info);
+}
+function ts_intersection_type(types2, loc_info) {
+  const node = (
+    /** @type {AST.TSIntersectionType} */
+    {
+      type: "TSIntersectionType",
+      types: types2,
+      metadata: { path: [] }
+    }
+  );
+  return set_location(node, loc_info);
+}
 function ts_keyword_type(keyword, loc_info) {
   const keyword_to_type = {
     string: "TSStringKeyword",
@@ -11747,6 +11961,14 @@ function ts_type_alias(id2, type_annotation, loc_info) {
   );
   return set_location(node, loc_info);
 }
+function member_id(path) {
+  const parts = path.split(".");
+  let expression = id(parts[0]);
+  for (let i2 = 1; i2 < parts.length; i2 += 1) {
+    expression = member(expression, id(parts[i2]));
+  }
+  return expression;
+}
 function object(properties, loc_info) {
   const node = { type: "ObjectExpression", properties, metadata: { path: [] } };
   return set_location(node, loc_info);
@@ -11778,10 +12000,39 @@ function assignment_prop(key2, value, computed = false, shorthand = false) {
     metadata: { path: [] }
   };
 }
+function prop_def(key2, value, computed = false, is_static = false) {
+  return (
+    /** @type {AST.PropertyDefinition} */
+    {
+      type: "PropertyDefinition",
+      key: key2,
+      value,
+      decorators: [],
+      computed,
+      static: is_static,
+      metadata: { path: [] }
+    }
+  );
+}
 function quasi(cooked, tail = false) {
   const raw = sanitize_template_string(cooked);
   return { type: "TemplateElement", value: { raw, cooked }, tail, metadata: { path: [] } };
 }
+function rest(argument) {
+  return { type: "RestElement", argument, metadata: { path: [] } };
+}
+function sequence(expressions) {
+  return { type: "SequenceExpression", expressions, metadata: { path: [] } };
+}
+function set(name, body) {
+  return (
+    /** @type {AST.Property & { value: AST.FunctionExpression}} */
+    prop("set", key(name), function_builder(null, [id("$$value")], block(body)))
+  );
+}
+function spread(argument) {
+  return { type: "SpreadElement", argument, metadata: { path: [] } };
+}
 function stmt(expression) {
   return { type: "ExpressionStatement", expression, metadata: { path: [] } };
 }
@@ -11789,16 +12040,89 @@ function template(elements, expressions, loc_info) {
   const node = { type: "TemplateLiteral", quasis: elements, expressions, metadata: { path: [] } };
   return set_location(node, loc_info);
 }
+function thunk(expression, async2 = false) {
+  const fn = arrow([], expression);
+  if (async2) fn.async = true;
+  return unthunk(fn);
+}
+function unthunk(expression) {
+  if (expression.type === "ArrowFunctionExpression" && expression.async === false && expression.body.type === "CallExpression" && expression.body.callee.type === "Identifier" && expression.params.length === expression.body.arguments.length && expression.params.every((param, index) => {
+    const arg = (
+      /** @type {AST.SimpleCallExpression} */
+      expression.body.arguments[index]
+    );
+    return param.type === "Identifier" && arg.type === "Identifier" && param.name === arg.name;
+  })) {
+    return expression.body.callee;
+  }
+  return expression;
+}
+function new_builder(expression, loc_info, ...args) {
+  if (typeof expression === "string") expression = id(expression);
+  const node = {
+    callee: expression,
+    arguments: args,
+    type: "NewExpression",
+    metadata: { path: [] }
+  };
+  return set_location(node, loc_info);
+}
+function update(operator, argument, prefix = false) {
+  return { type: "UpdateExpression", operator, argument, prefix, metadata: { path: [] } };
+}
+function do_while(test, body) {
+  return { type: "DoWhileStatement", test, body, metadata: { path: [] } };
+}
 var true_instance = literal2(true);
 var false_instance = literal2(false);
 var null_instance = literal2(null);
+var debugger_builder = {
+  type: "DebuggerStatement",
+  metadata: { path: [] }
+};
+var this_instance = {
+  type: "ThisExpression",
+  metadata: { path: [] }
+};
 function let_builder(pattern, init2) {
   return declaration("let", [declarator(pattern, init2)]);
 }
 function const_builder(pattern, init2) {
   return declaration("const", [declarator(pattern, init2)]);
 }
-function function_builder(id2, params, body, async = false, type_parameters, loc_info) {
+function var_builder(pattern, init2) {
+  return declaration("var", [declarator(pattern, init2)]);
+}
+function for_builder(init2, test, update2, body) {
+  return { type: "ForStatement", init: init2, test, update: update2, body, metadata: { path: [] } };
+}
+function for_of(left, right, body, await_flag = false, loc_info) {
+  const node = {
+    type: "ForOfStatement",
+    left,
+    right,
+    body,
+    await: await_flag,
+    metadata: { path: [] }
+  };
+  return set_location(node, loc_info);
+}
+function method(kind, key2, params, body, computed = false, is_static = false) {
+  return (
+    /** @type {AST.MethodDefinition} */
+    {
+      type: "MethodDefinition",
+      key: key2,
+      kind,
+      value: function_builder(null, params, block(body)),
+      decorators: [],
+      computed,
+      static: is_static,
+      metadata: { path: [] }
+    }
+  );
+}
+function function_builder(id2, params, body, async2 = false, type_parameters, loc_info) {
   const node = {
     type: "FunctionExpression",
     id: id2,
@@ -11806,7 +12130,7 @@ function function_builder(id2, params, body, async = false, type_parameters, loc
     body,
     typeParameters: type_parameters,
     generator: false,
-    async,
+    async: async2,
     metadata: { path: [] }
   };
   return set_location(node, loc_info);
@@ -11815,6 +12139,16 @@ function if_builder(test, consequent, alternate, loc_info) {
   const node = { type: "IfStatement", test, consequent, alternate, metadata: { path: [] } };
   return set_location(node, loc_info);
 }
+function import_all(as, source, attributes = [], importKind = "value") {
+  return {
+    type: "ImportDeclaration",
+    source: literal2(source),
+    specifiers: [import_namespace(as)],
+    attributes,
+    importKind,
+    metadata: { path: [] }
+  };
+}
 function imports(parts, source, attributes = [], importKind = "value") {
   return {
     type: "ImportDeclaration",
@@ -11848,6 +12182,13 @@ function return_builder(argument = null, loc_info) {
   const node = { type: "ReturnStatement", argument, metadata: { path: [] } };
   return set_location(node, loc_info);
 }
+function throw_error(str) {
+  return {
+    type: "ThrowStatement",
+    argument: new_builder("Error", void 0, literal2(str)),
+    metadata: { path: [] }
+  };
+}
 function try_builder(block2, handler = null, finalizer = null, pending = null) {
   return {
     type: "TryStatement",
@@ -11985,6 +12326,17 @@ function jsx_member(object3, property) {
     metadata: { path: [] }
   };
 }
+function jsx_spread_attribute(argument, loc_info) {
+  const node = (
+    /** @type {ESTreeJSX.JSXSpreadAttribute} */
+    {
+      type: "JSXSpreadAttribute",
+      argument,
+      metadata: { path: [] }
+    }
+  );
+  return set_location(node, loc_info);
+}
 function jsx_text(value, raw, loc_info) {
   const node = (
     /** @type {ESTreeJSX.JSXText} */
@@ -12015,8 +12367,18 @@ function switch_case(test = null, consequent = []) {
   };
 }
 var void0 = unary("void", literal2(0));
+var break_statement = {
+  type: "BreakStatement",
+  label: null,
+  metadata: { path: [] }
+};
+var continue_statement = {
+  type: "ContinueStatement",
+  label: null,
+  metadata: { path: [] }
+};
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/utils/ast.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/utils/ast.js
 function is_ast_node(value) {
   return !!value && typeof value === "object" && "type" in value;
 }
@@ -12064,9 +12426,6 @@ function is_function_node(node) {
 function is_function_or_class_node(node) {
   return !!node && (is_function_node(node) || is_class_node(node));
 }
-function is_function_or_component_node(node) {
-  return is_function_node(node);
-}
 function is_class_node(node) {
   return node.type === "ClassExpression" || node.type === "ClassDeclaration";
 }
@@ -12118,23 +12477,6 @@ function is_transparent_expression_wrapper(parent, child) {
   return (parent.type === "ParenthesizedExpression" || parent.type === "TSAsExpression" || parent.type === "TSSatisfiesExpression" || parent.type === "TSNonNullExpression" || parent.type === "TSInstantiationExpression" || parent.type === "TSTypeAssertion" || parent.type === "ChainExpression") && /** @type {{ expression?: AST.Node }} */
   parent.expression === child;
 }
-function is_supported_lazy_assignment_position(node, path) {
-  if (node.operator !== "=" || node.left.type !== "ObjectPattern" && node.left.type !== "ArrayPattern" || !node.left.lazy) {
-    return false;
-  }
-  let child = node;
-  for (let i2 = path.length - 1; i2 >= 0; i2 -= 1) {
-    const parent = path[i2];
-    if (is_transparent_expression_wrapper(parent, child)) {
-      child = parent;
-      continue;
-    }
-    if (parent.type !== "ExpressionStatement" || parent.expression !== child) return false;
-    const container = path[i2 - 1];
-    return !!container && is_statement_list_item(container, parent);
-  }
-  return false;
-}
 function object2(expression) {
   while (expression.type === "MemberExpression") {
     expression = /** @type {AST.MemberExpression | AST.Identifier} */
@@ -12180,7 +12522,7 @@ function extract_identifiers(pattern) {
   return unwrap_pattern(pattern, []).filter((node) => node.type === "Identifier");
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/parse/index.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/parse/index.js
 var BINDING_TYPES = {
   BIND_NONE: 0,
   // Not a binding
@@ -13129,13 +13471,13 @@ var sha256 = /* @__PURE__ */ createHasher(
   /* @__PURE__ */ oidNist(1)
 );
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/utils/hashing.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/utils/hashing.js
 var regex_return_characters = /\r/g;
 function strong_hash(str) {
   return bytesToHex(sha256(utf8ToBytes(str.replace(regex_return_characters, "")))).slice(0, 8);
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/parse/style.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/parse/style.js
 var REGEX_MATCHER = /^[~^$*|]?=/;
 var REGEX_ATTRIBUTE_FLAGS = /^[a-zA-Z]+/;
 var REGEX_COMMENT_CLOSE = /\*\//;
@@ -13702,7 +14044,7 @@ function read_identifier(parser) {
   return identifier;
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/errors.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/errors.js
 function error(message, filename, node, errors, comments, code) {
   if (errors && comments && is_error_suppressed(node, comments)) {
     return;
@@ -13752,7 +14094,7 @@ function is_error_suppressed(node, comments) {
   return false;
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/diagnostics.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/diagnostics.js
 var DIAGNOSTIC_CODES = {
   /** A recognized `import.meta.env.platform.*` flag is used without a selected platform. */
   PLATFORM_REQUIRED: "tsrx-platform-required",
@@ -13762,7 +14104,6 @@ var DIAGNOSTIC_CODES = {
   TEMPLATE_EXPRESSION_TRAILING_SEMICOLON: "tsrx-template-expression-trailing-semicolon",
   TEMPLATE_RETURN_STATEMENT: "tsrx-template-return-statement",
   FORGOTTEN_STATEMENT_CONTAINER: "tsrx-forgotten-statement-container",
-  UNSUPPORTED_LAZY_ASSIGNMENT_POSITION: "tsrx-unsupported-lazy-assignment-position",
   /** `<style apply>` carries no expression value. */
   STYLE_APPLY_VALUE: "tsrx-style-apply-value",
   /** An `apply` entry is not an identifier, member, or array of those, or does not resolve to a style block. */
@@ -13787,10 +14128,9 @@ var DIAGNOSTIC_CODES = {
   CSS_GLOBAL_PLACEMENT: "tsrx-css-global-placement"
 };
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/analyze/validation.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/analyze/validation.js
 var TSRX_RETURN_STATEMENT_ERROR = "Return statements are not allowed inside TSRX templates. Move the return before the TSRX return value, or use conditional rendering instead.";
 var TSRX_FORGOTTEN_STATEMENT_CONTAINER_ERROR = "This TSRX template output is unused. Return it, assign it to a value that is rendered, or make it part of the rendered output of a function '@{...}' body.";
-var TSRX_UNSUPPORTED_LAZY_ASSIGNMENT_POSITION_ERROR = "Lazy destructuring assignments require a directly lazy target as a standalone statement inside a program, block, TSRX code block, or switch case.";
 var TSRX_STYLE_APPLY_VALUE_ERROR = "The 'apply' attribute of a <style> block requires an expression value: apply={theme} or apply={[a, b]}.";
 var TSRX_STYLE_APPLY_DUPLICATE_ERROR = "A <style> block accepts a single 'apply' attribute; pass several themes as an array: apply={[a, b]}.";
 var TSRX_STYLE_APPLY_UNSUPPORTED_HOST_ERROR = "The 'apply' attribute is only supported on scoped <style> blocks, not on <head> styles or resource styles.";
@@ -13819,16 +14159,6 @@ function validate_forgotten_statement_container(node, filename, errors, comments
     DIAGNOSTIC_CODES.FORGOTTEN_STATEMENT_CONTAINER
   );
 }
-function validate_unsupported_lazy_assignment_position(node, filename, errors, comments) {
-  error(
-    TSRX_UNSUPPORTED_LAZY_ASSIGNMENT_POSITION_ERROR,
-    filename ?? null,
-    node,
-    errors,
-    comments,
-    DIAGNOSTIC_CODES.UNSUPPORTED_LAZY_ASSIGNMENT_POSITION
-  );
-}
 function is_template_value_position(parent, child) {
   switch (parent.type) {
     case "VariableDeclarator":
@@ -13868,7 +14198,7 @@ function validate_style(message, code, node, filename, errors, comments) {
   error(message, filename, node, errors, comments, code);
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/plugin.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/plugin.js
 var CharCode = Object.freeze({
   tab: 9,
   lineFeed: 10,
@@ -13969,62 +14299,6 @@ function get_argument_clash_reported_names(check_clashes) {
   }
   return reported_names;
 }
-function get_lazy_binding_pos(refDestructuringErrors) {
-  return refDestructuringErrors?.lazyBindingPos ?? -1;
-}
-var lazy_target_wrapper_types = /* @__PURE__ */ new Set([
-  "ParenthesizedExpression",
-  "TSAsExpression",
-  "TSSatisfiesExpression",
-  "TSNonNullExpression",
-  "TSTypeAssertion",
-  "TSTypeCastExpression"
-]);
-function pattern_position_contains_lazy(node, pos) {
-  if (!node || typeof node !== "object") return false;
-  if (
-    /** @type {AST.ObjectPattern | AST.ArrayPattern} */
-    node.lazy && /** @type {number} */
-    node.start === pos + 1
-  ) {
-    return true;
-  }
-  if (lazy_target_wrapper_types.has(node.type)) {
-    return pattern_position_contains_lazy(
-      /** @type {{ expression: AST.Node }} */
-      /** @type {unknown} */
-      node.expression,
-      pos
-    );
-  }
-  switch (node.type) {
-    case "ObjectExpression":
-    case "ObjectPattern":
-      return node.properties.some(
-        (property) => pattern_position_contains_lazy(
-          property.type === "Property" ? (
-            /** @type {AST.Node} */
-            property.value
-          ) : property.argument,
-          pos
-        )
-      );
-    case "ArrayExpression":
-    case "ArrayPattern":
-      return node.elements.some(
-        (element) => element && pattern_position_contains_lazy(element, pos)
-      );
-    case "AssignmentExpression":
-      return node.operator === "=" && pattern_position_contains_lazy(node.left, pos);
-    case "AssignmentPattern":
-      return pattern_position_contains_lazy(node.left, pos);
-    case "SpreadElement":
-    case "RestElement":
-      return pattern_position_contains_lazy(node.argument, pos);
-    default:
-      return false;
-  }
-}
 function can_start_tag_after_lt(input, index) {
   const next = index + 1 < input.length ? input.charCodeAt(index + 1) : -1;
   return next === CharCode.slash || next === CharCode.greaterThan || next === CharCode.openBrace || next === CharCode.at || next === CharCode.dollar || next === CharCode.underscore || next >= CharCode.uppercaseA && next <= CharCode.uppercaseZ || next >= CharCode.lowercaseA && next <= CharCode.lowercaseZ;
@@ -15115,16 +15389,6 @@ function TSRXPlugin(config) {
        * @type {Parse.Parser['parseExprAtom']}
        */
       parseExprAtom(refDestructuringErrors, forInit, forNew) {
-        if (refDestructuringErrors && this.type === tt.bitwiseAND && (this.input.charCodeAt(this.end) === CharCode.openBrace || this.input.charCodeAt(this.end) === CharCode.openBracket)) {
-          if (get_lazy_binding_pos(refDestructuringErrors) < 0) {
-            refDestructuringErrors.lazyBindingPos = this.start;
-          }
-          return (
-            /** @type {AST.Expression} */
-            /** @type {unknown} */
-            this.parseBindingAtom()
-          );
-        }
         if (this.input.charCodeAt(this.start) === CharCode.at && this.type !== tstt.jsxText) {
           if (this.#isCodeBlockStart(this.start)) {
             return this.#parseCodeBlock();
@@ -15236,20 +15500,20 @@ function TSRXPlugin(config) {
               this.raise(this.start, "Expected `{` after JSX control-flow directive.");
             }
             const emptyKeyword = this.#lastClauseKeywordSpan;
-            let empty2;
+            let empty3;
             this.#templateControlFlowBlockDepth++;
             try {
-              empty2 = this.parseBlock();
+              empty3 = this.parseBlock();
             } finally {
               this.#templateControlFlowBlockDepth--;
             }
-            node.empty = empty2;
+            node.empty = empty3;
             node.emptyKeyword = emptyKeyword;
-            node.end = empty2.end;
+            node.end = empty3.end;
             node.loc.end = /** @type {AST.NodeWithLocation} */
-            empty2.loc.end;
+            empty3.loc.end;
             if (node.range) node.range[1] = /** @type {number} */
-            empty2.end;
+            empty3.end;
           } else if (this.#isUnprefixedDirectiveClauseContinuation("empty", ["{"])) {
             this.raise(this.start, "Expected `@empty` after `@for` block.");
           } else {
@@ -16455,43 +16719,6 @@ function TSRXPlugin(config) {
         }
         return super.getTokenFromCode(code);
       }
-      /**
-       * Override isLet to recognize `let &{` and `let &[` as variable declarations.
-       * Acorn's isLet checks the char after `let` and only recognizes `{`, `[`, or identifiers.
-       * The `&` character is not in that set, so `let &{...}` would not be parsed as a declaration.
-       * @type {Parse.Parser['isLet']}
-       */
-      isLet(context) {
-        if (!this.isContextual("let")) return false;
-        const skip = /\s*/y;
-        skip.lastIndex = this.pos;
-        const match = skip.exec(this.input);
-        if (!match) return super.isLet(context);
-        const next = this.pos + match[0].length;
-        const nextCh = this.input.charCodeAt(next);
-        if (nextCh === CharCode.ampersand) {
-          const afterAmp = this.input.charCodeAt(next + 1);
-          if (afterAmp === CharCode.openBrace || afterAmp === CharCode.openBracket) return true;
-        }
-        return super.isLet(context);
-      }
-      /**
-       * Parse binding atom - handles lazy destructuring patterns (&{...} and &[...])
-       * When & is directly followed by { or [, parse as a lazy destructuring pattern.
-       * The resulting ObjectPattern/ArrayPattern node gets a `lazy: true` flag.
-       */
-      parseBindingAtom() {
-        if (this.type === tt.bitwiseAND) {
-          const charAfterAmp = this.input.charCodeAt(this.end);
-          if (charAfterAmp === CharCode.openBrace || charAfterAmp === CharCode.openBracket) {
-            this.next();
-            const pattern = super.parseBindingAtom();
-            pattern.lazy = true;
-            return pattern;
-          }
-        }
-        return super.parseBindingAtom();
-      }
       /**
        * Acorn reports only the second duplicate function parameter. When collecting,
        * report the first one too so editor diagnostics can underline both
@@ -16550,39 +16777,10 @@ function TSRXPlugin(config) {
         }
         return expr;
       }
-      /**
-       * A recorded lazy binding pattern that never became a binding or
-       * assignment target is a pending error, exactly like `{a = b}` shorthand
-       * outside a destructuring pattern. Acorn calls the throwing form at every
-       * boundary where a context definitively stayed an expression
-       * (parenthesized expressions, call arguments, plain assignments'
-       * right-hand sides, …) — that is where the record is enforced.
-       *
-       * The non-throwing form is deliberately left untouched: Acorn uses it in
-       * parseExprOps/parseMaybeConditional to stop parsing operators early, and
-       * returning true there would cut the pattern off from the `as` /
-       * `satisfies` operator lane before toAssignable can accept the wrapped
-       * target (`[&{ a } as T] = arr`). Every path that keeps a stale record
-       * still ends in a throwing check.
-       *
-       * @type {Parse.Parser['checkExpressionErrors']}
-       */
-      checkExpressionErrors(refDestructuringErrors, andThrow) {
-        if (andThrow) {
-          const lazy_binding_pos = get_lazy_binding_pos(refDestructuringErrors);
-          if (lazy_binding_pos >= 0) {
-            this.raise(
-              lazy_binding_pos,
-              "Lazy binding patterns are only valid as binding or assignment targets"
-            );
-          }
-        }
-        return super.checkExpressionErrors(refDestructuringErrors, andThrow);
-      }
       /**
        * acorn-typescript unwraps TS expression wrappers in checkLValSimple,
        * which is only right for simple targets (`[b as any] = arr`). A wrapped
-       * destructuring pattern (`[&{ a } as T] = arr`) reaches checkLValPattern
+       * destructuring pattern (`[{ a } as T] = arr`) reaches checkLValPattern
        * still wrapped — toAssignableList ignores return values, so the wrapper
        * survives conversion — and would fall through to checkLValSimple's
        * "Assigning to rvalue". Unwrap here so wrapped patterns take the
@@ -16600,29 +16798,6 @@ function TSRXPlugin(config) {
         }
         return super.checkLValPattern(node, bindingType, checkClashes);
       }
-      /**
-       * Converting a node into an assignment target resolves any lazy binding
-       * pattern recorded inside it — the pattern landed in a valid position,
-       * so its pending error must not outlive the conversion (e.g.
-       * `({ pair: &{ a } } = obj)` would otherwise still raise when the
-       * enclosing parenthesized expression runs checkExpressionErrors). This
-       * mirrors how Acorn resets `shorthandAssign` once the shorthand ends up
-       * inside a converted left-hand side.
-       *
-       * @type {Parse.Parser['toAssignable']}
-       */
-      toAssignable(node, isBinding, refDestructuringErrors, preserveTypeScriptWrapper) {
-        const lazy_binding_pos = get_lazy_binding_pos(refDestructuringErrors);
-        if (lazy_binding_pos >= 0 && pattern_position_contains_lazy(node, lazy_binding_pos)) {
-          refDestructuringErrors.lazyBindingPos = -1;
-        }
-        return super.toAssignable(
-          node,
-          isBinding,
-          refDestructuringErrors,
-          preserveTypeScriptWrapper
-        );
-      }
       /**
        * Override checkLocalExport to check all scopes in the scope stack.
        * This is needed because submodules create nested scopes, but exports
@@ -18239,39 +18414,6 @@ function TSRXPlugin(config) {
             this.finishNode(node, "ExpressionStatement")
           );
         }
-        if (this.type === tt.bitwiseAND) {
-          const charAfterAmp = this.input.charCodeAt(this.end);
-          if (charAfterAmp === CharCode.openBrace || charAfterAmp === CharCode.openBracket) {
-            const node = (
-              /** @type {AST.ExpressionStatement} */
-              this.startNode()
-            );
-            const assign_node = (
-              /** @type {AST.AssignmentExpression} */
-              this.startNode()
-            );
-            this.next();
-            const left = (
-              /** @type {AST.ArrayPattern | AST.ObjectPattern} */
-              /** @type {unknown} */
-              this.parseExprAtom()
-            );
-            this.toAssignable(left, false);
-            left.lazy = true;
-            this.expect(tt.eq);
-            assign_node.operator = "=";
-            assign_node.left = left;
-            assign_node.right = /** @type {AST.Expression} */
-            this.parseMaybeAssign();
-            node.expression = /** @type {AST.AssignmentExpression} */
-            this.finishNode(assign_node, "AssignmentExpression");
-            this.semicolon();
-            return (
-              /** @type {AST.ExpressionStatement} */
-              this.finishNode(node, "ExpressionStatement")
-            );
-          }
-        }
         return super.parseStatement(context, topLevel, exports);
       }
       /**
@@ -18311,13 +18453,13 @@ function TSRXPlugin(config) {
   };
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/parse/parse-module.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/parse/parse-module.js
 var parse4 = createParser(TSRXPlugin());
 function parse_module(source, filename, options) {
   return parse4(source, filename, options);
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/utils/is-reference.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/utils/is-reference.js
 function is_reference(node, parent) {
   if (node.type === "MemberExpression") {
     return !node.computed && is_reference(node.object, node);
@@ -18354,7 +18496,7 @@ function is_reference(node, parent) {
   }
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/utils/dom.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/utils/dom.js
 var RESERVED_WORDS = [
   "arguments",
   "await",
@@ -18457,12 +18599,12 @@ var DOM_PROPERTIES = [
   "disableRemotePlayback"
 ];
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/identifier-utils.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/identifier-utils.js
 var IDENTIFIER_OBFUSCATION_PREFIX = "_$_";
 var SERVER_IDENTIFIER = IDENTIFIER_OBFUSCATION_PREFIX + "server_$_";
 var CSS_HASH_IDENTIFIER = IDENTIFIER_OBFUSCATION_PREFIX + "hash";
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/scope.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/scope.js
 function create_scopes(ast, root, parent, error_options) {
   const scopes = /* @__PURE__ */ new Map();
   const scope = new Scope3(root, parent, false, error_options);
@@ -18843,7 +18985,7 @@ var ScopeRoot = class {
   }
 };
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/constants.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/constants.js
 var TEMPLATE_USE_IMPORT_NODE = 1 << 1;
 var IS_CONTROLLED = 1 << 2;
 var IS_INDEXED = 1 << 3;
@@ -18855,7 +18997,7 @@ var HYDRATION_END = "]";
 var BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
 var BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/comment-utils.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/comment-utils.js
 function is_ts_pragma(comment) {
   if (comment.type !== "Line") return false;
   const pragmas = ["@ts-ignore", "@ts-expect-error", "@ts-nocheck", "@ts-check"];
@@ -18911,7 +19053,7 @@ function format_comment(comment) {
   }
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/jsx/ast-builders.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/jsx/ast-builders.js
 function set_loc(node, source_node) {
   node.metadata ??= { path: [] };
   if (has_location(source_node)) {
@@ -19114,7 +19256,7 @@ function clone_ast_node(node, with_locations = true) {
   return clone;
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/style-ref.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/style-ref.js
 var regex_backslash_and_following_character = /\\(.)/g;
 function create_style_class_map(component, css, options = {}) {
   return build_style_class_map(
@@ -19329,7 +19471,7 @@ function get_standalone_class_selector(complex_selector) {
   return selector.type === "ClassSelector" ? selector : null;
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/analyze/style-analyze.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/analyze/style-analyze.js
 function nearest_scope(path, scopes) {
   for (let i2 = path.length - 1; i2 >= 0; i2 -= 1) {
     const scope = scopes.get(path[i2]);
@@ -19616,50 +19758,7 @@ function analyze_styles(ast, scopes, state) {
   return styles;
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/analyze/index.js
-function find_first_lazy_pattern(node) {
-  if ((node.type === "ObjectPattern" || node.type === "ArrayPattern") && node.lazy) {
-    return node;
-  }
-  switch (node.type) {
-    case "AssignmentPattern":
-      return find_first_lazy_pattern(node.left);
-    case "RestElement":
-      return find_first_lazy_pattern(node.argument);
-    case "ObjectPattern":
-      for (const property of node.properties) {
-        const lazy = property.type === "Property" ? find_first_lazy_pattern(property.value) : find_first_lazy_pattern(property.argument);
-        if (lazy) return lazy;
-      }
-      return null;
-    case "ArrayPattern":
-      for (const element of node.elements) {
-        if (!element) continue;
-        const lazy = find_first_lazy_pattern(element);
-        if (lazy) return lazy;
-      }
-      return null;
-    default: {
-      const expression = (
-        /** @type {{ expression?: AST.Node }} */
-        node.expression
-      );
-      return expression && is_transparent_expression_wrapper(node, expression) ? find_first_lazy_pattern(expression) : null;
-    }
-  }
-}
-function visit_assignment_expression(node, { next, path, state }) {
-  const lazy = find_first_lazy_pattern(node.left);
-  if (lazy && !is_supported_lazy_assignment_position(node, path)) {
-    validate_unsupported_lazy_assignment_position(
-      lazy,
-      state.filename,
-      state.collect ? state.errors : void 0,
-      state.comments
-    );
-  }
-  next();
-}
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/analyze/index.js
 function is_free_floating_template(node, path) {
   let child = node;
   for (let i2 = path.length - 1; i2 >= 0; i2 -= 1) {
@@ -19710,7 +19809,6 @@ function visit_class(_node, { next, state }) {
   });
 }
 var visitors = {
-  AssignmentExpression: visit_assignment_expression,
   FunctionDeclaration: visit_function,
   FunctionExpression: visit_function,
   ArrowFunctionExpression: visit_function,
@@ -20913,14 +21011,14 @@ var MagicString = class _MagicString {
   }
 };
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/platform.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/platform.js
 var PLATFORMS = (
   /** @type {const} */
   ["web", "ios", "android"]
 );
 var platform_set = new Set(PLATFORMS);
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/imports.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/imports.js
 function with_deferred_imports(visitors3) {
   const print_import_declaration = visitors3.ImportDeclaration;
   const print_import_expression = visitors3.ImportExpression;
@@ -21229,7 +21327,7 @@ function print(node, visitors3, opts = {}) {
   };
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/analyze/css-analyze.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/analyze/css-analyze.js
 function is_global_block_selector(simple_selector) {
   return simple_selector.type === "PseudoClassSelector" && simple_selector.name === "global" && simple_selector.args === null;
 }
@@ -21553,7 +21651,7 @@ var ts_default = (options = {}) => {
     }
     context.write(" }");
   }
-  function sequence(context, nodes, until, pad, separator = ",", trailing_newline = true) {
+  function sequence2(context, nodes, until, pad, separator = ",", trailing_newline = true) {
     let multiline = false;
     let length = -1;
     const multiline_nodes = [];
@@ -21667,7 +21765,7 @@ var ts_default = (options = {}) => {
      */
     "ArrayExpression|ArrayPattern": (node, context) => {
       context.write("[", token_at(node.loc?.start));
-      sequence(
+      sequence2(
         context,
         /** @type {TSESTree.Node[]} */
         node.elements,
@@ -21803,7 +21901,7 @@ var ts_default = (options = {}) => {
       }
       if (node.implements && node.implements.length > 0) {
         context.write("implements");
-        sequence(context, node.implements, node.body.loc?.start ?? null, true);
+        sequence2(context, node.implements, node.body.loc?.start ?? null, true);
       }
       context.visit(node.body);
     },
@@ -21862,7 +21960,7 @@ var ts_default = (options = {}) => {
         context.visit(node.typeParameters);
       }
       context.write("(");
-      sequence(context, node.params, (node.returnType ?? node.body).loc?.start ?? null, false);
+      sequence2(context, node.params, (node.returnType ?? node.body).loc?.start ?? null, false);
       context.write(")");
       if (node.returnType) context.visit(node.returnType);
       context.write(" ");
@@ -21904,7 +22002,7 @@ var ts_default = (options = {}) => {
       if (node.optional) context.write("?");
       if (node.typeParameters) context.visit(node.typeParameters);
       context.write("(");
-      sequence(
+      sequence2(
         context,
         node.value.params,
         (node.value.returnType ?? node.value.body)?.loc?.start ?? node.loc?.end ?? null,
@@ -21994,7 +22092,7 @@ var ts_default = (options = {}) => {
         context.visit(node.typeParameters);
       }
       context.write("(");
-      sequence(
+      sequence2(
         context,
         // @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
         node.parameters ?? node.params,
@@ -22018,7 +22116,7 @@ var ts_default = (options = {}) => {
       }
       if (node.typeParameters) context.visit(node.typeParameters);
       context.write("(");
-      sequence(
+      sequence2(
         context,
         // @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
         node.parameters ?? node.params,
@@ -22054,7 +22152,7 @@ var ts_default = (options = {}) => {
         context.visit(node.typeParameters);
       }
       context.write("(");
-      sequence(context, node.params, (node.returnType ?? node.body).loc?.start ?? null, false);
+      sequence2(context, node.params, (node.returnType ?? node.body).loc?.start ?? null, false);
       context.write(")");
       if (node.returnType) context.visit(node.returnType);
       context.write(" => ");
@@ -22216,7 +22314,7 @@ var ts_default = (options = {}) => {
         else context.write("type ");
       }
       context.write("{");
-      sequence(context, node.specifiers, node.source?.loc?.start ?? node.loc?.end ?? null, true);
+      sequence2(context, node.specifiers, node.source?.loc?.start ?? node.loc?.end ?? null, true);
       context.write("}");
       if (node.source) {
         context.write(" from ");
@@ -22333,7 +22431,7 @@ var ts_default = (options = {}) => {
       }
       if (named_specifiers.length > 0) {
         context.write("{");
-        sequence(context, named_specifiers, node.source.loc?.start ?? null, true);
+        sequence2(context, named_specifiers, node.source.loc?.start ?? null, true);
         context.write("}");
       }
       context.write(" from ");
@@ -22404,12 +22502,12 @@ var ts_default = (options = {}) => {
     NewExpression: shared["CallExpression|NewExpression"],
     ObjectExpression(node, context) {
       context.write("{", token_at(node.loc?.start));
-      sequence(context, node.properties, node.loc?.end ?? null, true);
+      sequence2(context, node.properties, node.loc?.end ?? null, true);
       context.write("}", token_before(node.loc?.end));
     },
     ObjectPattern(node, context) {
       context.write("{", token_at(node.loc?.start));
-      sequence(context, node.properties, node.loc?.end ?? null, true);
+      sequence2(context, node.properties, node.loc?.end ?? null, true);
       context.write("}", token_before(node.loc?.end));
       if (node.typeAnnotation) context.visit(node.typeAnnotation);
     },
@@ -22446,7 +22544,7 @@ var ts_default = (options = {}) => {
         context.visit(node.key);
         if (node.computed) context.write("]", token_at(node.key.loc?.end));
         context.write("(");
-        sequence(
+        sequence2(
           context,
           node.value.params,
           (node.value.returnType ?? node.value.body).loc?.start ?? null,
@@ -22485,7 +22583,7 @@ var ts_default = (options = {}) => {
     },
     SequenceExpression(node, context) {
       context.write("(");
-      sequence(context, node.expressions, node.loc?.end ?? null, false);
+      sequence2(context, node.expressions, node.loc?.end ?? null, false);
       context.write(")");
     },
     SpreadElement: shared["RestElement|SpreadElement"],
@@ -22657,7 +22755,7 @@ var ts_default = (options = {}) => {
         context.visit(node.typeParameters);
       }
       context.write("(");
-      sequence(context, node.params, node.returnType?.loc?.start ?? node.loc?.end ?? null, false);
+      sequence2(context, node.params, node.returnType?.loc?.start ?? node.loc?.end ?? null, false);
       context.write(")");
       if (node.returnType) {
         context.visit(node.returnType);
@@ -22713,7 +22811,7 @@ var ts_default = (options = {}) => {
     },
     TSTypeLiteral(node, context) {
       context.write("{ ");
-      sequence(context, node.members, node.loc?.end ?? null, false, ";");
+      sequence2(context, node.members, node.loc?.end ?? null, false, ";");
       context.write(" }");
     },
     TSPropertySignature(node, context) {
@@ -22846,7 +22944,7 @@ var ts_default = (options = {}) => {
     TSIndexSignature(node, context) {
       if (node.readonly) context.write("readonly ");
       context.write("[");
-      sequence(context, node.parameters, node.typeAnnotation?.loc?.start ?? null, false);
+      sequence2(context, node.parameters, node.typeAnnotation?.loc?.start ?? null, false);
       context.write("]");
       context.visit(node.typeAnnotation);
     },
@@ -22896,7 +22994,7 @@ var ts_default = (options = {}) => {
         context.visit(node.typeParameters);
       }
       context.write("(");
-      sequence(
+      sequence2(
         context,
         // @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
         node.parameters ?? node.params,
@@ -22911,7 +23009,7 @@ var ts_default = (options = {}) => {
     },
     TSTupleType(node, context) {
       context.write("[");
-      sequence(context, node.elementTypes, node.loc?.end ?? null, false);
+      sequence2(context, node.elementTypes, node.loc?.end ?? null, false);
       context.write("]");
     },
     TSNamedTupleMember(node, context) {
@@ -22921,10 +23019,10 @@ var ts_default = (options = {}) => {
       context.visit(node.elementType);
     },
     TSUnionType(node, context) {
-      sequence(context, node.types, node.loc?.end ?? null, false, " |", false);
+      sequence2(context, node.types, node.loc?.end ?? null, false, " |", false);
     },
     TSIntersectionType(node, context) {
-      sequence(context, node.types, node.loc?.end ?? null, false, " &", false);
+      sequence2(context, node.types, node.loc?.end ?? null, false, " &", false);
     },
     TSInferType(node, context) {
       context.write("infer ");
@@ -23002,7 +23100,7 @@ var ts_default = (options = {}) => {
       context.write(" {");
       context.indent();
       context.newline();
-      sequence(context, node.members ?? node.body.members, node.loc?.end ?? null, false);
+      sequence2(context, node.members ?? node.body.members, node.loc?.end ?? null, false);
       context.dedent();
       context.newline();
       context.write("}");
@@ -23043,7 +23141,7 @@ var ts_default = (options = {}) => {
       context.write("!");
     },
     TSInterfaceBody(node, context) {
-      sequence(context, node.body, node.loc?.end ?? null, true, ";");
+      sequence2(context, node.body, node.loc?.end ?? null, true, ";");
     },
     TSInterfaceDeclaration(node, context) {
       if (node.declare) context.write("declare ");
@@ -23052,7 +23150,7 @@ var ts_default = (options = {}) => {
       if (node.typeParameters) context.visit(node.typeParameters);
       if (node.extends && node.extends.length > 0) {
         context.write(" extends ");
-        sequence(context, node.extends, node.body.loc?.start ?? null, false);
+        sequence2(context, node.extends, node.body.loc?.start ?? null, false);
       }
       context.write(" {");
       context.visit(node.body);
@@ -23420,7 +23518,7 @@ var tsx_default = (options) => ({
   }
 });
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/jsx/helpers.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/jsx/helpers.js
 function in_jsx_child_context(path) {
   const parent = path[path.length - 1];
   return !!parent && (parent.type === "JSXElement" || parent.type === "JSXFragment");
@@ -23661,7 +23759,7 @@ function is_template_try_node(node) {
   return node?.type === "JSXTryExpression" || node?.type === "TryStatement" && node?.statementType === "TryStatement";
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/stylesheet.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/stylesheet.js
 var regex_css_browser_prefix = /^-((webkit)|(moz)|(o)|(ms))-/;
 var regex_css_name_boundary = /^[\s,;}]$/;
 var is_keyframes_node = (node) => remove_css_prefix(node.name) === "keyframes";
@@ -24016,885 +24114,11 @@ function render_css_result(stylesheets, minify = false) {
   };
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/lazy.js
-function generate_lazy_id(context) {
-  return `__lazy${context.lazy_next_id++}`;
-}
-function set_source_location(node, loc_info) {
-  if (has_location(loc_info)) {
-    node.start = loc_info.start;
-    node.end = loc_info.end;
-    node.loc = loc_info.loc;
-  }
-  return node;
-}
-function create_generated_identifier2(name, loc_info, source_name, source_length) {
-  const id2 = id(name);
-  if (source_name && source_name !== name) id2.metadata.source_name = source_name;
-  if (source_length != null) id2.metadata.source_length = source_length;
-  return set_source_location(id2, loc_info);
-}
-function get_lazy_pattern_mapping_range(pattern) {
-  if (!has_location(pattern)) return null;
-  const end = pattern.typeAnnotation?.start ?? pattern.end;
-  const end_loc = pattern.typeAnnotation?.loc?.start ?? pattern.loc.end;
-  return {
-    start: pattern.start,
-    end,
-    loc: {
-      start: pattern.loc.start,
-      end: end_loc
-    },
-    source_length: end - pattern.start
-  };
-}
-function get_static_property_name(node) {
-  if (node.type === "Identifier") return node.name;
-  if (node.type === "Literal") return String(node.value);
-  return null;
-}
-function get_type_property_keys(type_annotation) {
-  const keys = /* @__PURE__ */ new Map();
-  const type = type_annotation?.typeAnnotation;
-  if (type?.type !== "TSTypeLiteral") return keys;
-  for (const member2 of type.members) {
-    if (member2.type !== "TSPropertySignature") continue;
-    const key2 = member2.key;
-    if (key2.type !== "Identifier" && key2.type !== "Literal") continue;
-    const name = get_static_property_name(key2);
-    if (name != null && !keys.has(name)) keys.set(name, key2);
-  }
-  return keys;
-}
-function set_lazy_param_binding_mappings(lazy_id, pattern) {
-  if (pattern.type !== "ObjectPattern") return;
-  const type_keys = get_type_property_keys(lazy_id.typeAnnotation);
-  if (type_keys.size === 0) return;
-  const mappings = [];
-  for (const prop2 of pattern.properties) {
-    if (prop2.type === "RestElement" || prop2.computed) continue;
-    const value = prop2.value;
-    const actual = value.type === "AssignmentPattern" ? value.left : value;
-    if (actual.type !== "Identifier" || !has_location(actual)) continue;
-    const key_name = get_static_property_name(prop2.key);
-    const generated = key_name == null ? null : type_keys.get(key_name);
-    if (has_location(generated)) {
-      generated.metadata = { ...generated.metadata, disable_verification: true };
-      mappings.push({ source: actual, generated });
-    }
-  }
-  if (mappings.length > 0) {
-    lazy_id.metadata.lazy_param_binding_mappings = mappings;
-  }
-}
-function collect_lazy_bindings(pattern, source_name, lazy_bindings) {
-  collect_lazy_bindings_at(
-    pattern,
-    source_name,
-    () => create_generated_identifier2(source_name),
-    lazy_bindings
-  );
-}
-function collect_lazy_bindings_at(pattern, source_name, build_parent, lazy_bindings) {
-  if (pattern.type === "ObjectPattern") {
-    for (const prop2 of pattern.properties) {
-      if (prop2.type === "RestElement") continue;
-      const value = prop2.value;
-      const actual = value.type === "AssignmentPattern" ? value.left : value;
-      const key2 = prop2.key;
-      const computed = prop2.computed || key2.type !== "Identifier";
-      const build_self = (reference) => member(
-        build_parent(),
-        computed || key2.type !== "Identifier" ? { ...key2 } : create_generated_identifier2(key2.name, reference, reference?.name),
-        computed
-      );
-      if (actual.type === "Identifier") {
-        lazy_bindings.set(actual.name, { source_name, read: build_self });
-      } else if (actual.type === "ObjectPattern" || actual.type === "ArrayPattern") {
-        collect_lazy_bindings_at(actual, source_name, build_self, lazy_bindings);
-      }
-    }
-  } else if (pattern.type === "ArrayPattern") {
-    for (let i2 = 0; i2 < pattern.elements.length; i2++) {
-      const element = pattern.elements[i2];
-      if (!element) continue;
-      if (element.type === "RestElement") continue;
-      const actual = element.type === "AssignmentPattern" ? element.left : element;
-      const index = i2;
-      const build_self = () => member(build_parent(), literal2(index), true);
-      if (actual.type === "Identifier") {
-        lazy_bindings.set(actual.name, { source_name, read: build_self });
-      } else if (actual.type === "ObjectPattern" || actual.type === "ArrayPattern") {
-        collect_lazy_bindings_at(actual, source_name, build_self, lazy_bindings);
-      }
-    }
-  }
-}
-function collect_lazy_bindings_from_statements(statements, lazy_bindings) {
-  for (const stmt2 of statements) {
-    if (stmt2.type === "VariableDeclaration") {
-      for (const declarator2 of stmt2.declarations) {
-        visit_topmost_lazy_patterns(declarator2.id, (lazy) => {
-          if (!lazy.metadata?.lazy_id) return;
-          collect_lazy_bindings(lazy, lazy.metadata.lazy_id, lazy_bindings);
-        });
-      }
-    } else if (stmt2.type === "ExpressionStatement") {
-      const assignment2 = get_standalone_assignment(stmt2);
-      if (!assignment2 || assignment2.operator !== "=") continue;
-      visit_topmost_lazy_patterns(assignment2.left, (lazy) => {
-        if (!lazy.metadata?.lazy_id) return;
-        collect_lazy_bindings(lazy, lazy.metadata.lazy_id, lazy_bindings);
-      });
-    }
-  }
-}
-function get_standalone_assignment(statement) {
-  let expression = statement.expression;
-  while (expression.type !== "AssignmentExpression") {
-    const child = (
-      /** @type {{ expression?: AST.Node }} */
-      expression.expression
-    );
-    if (!child || !is_transparent_expression_wrapper(expression, child)) return null;
-    expression = child;
-  }
-  return expression;
-}
-function visit_topmost_lazy_patterns(pattern, visit) {
-  if (!pattern || typeof pattern !== "object") return;
-  if (pattern.type === "AssignmentPattern") {
-    visit_topmost_lazy_patterns(pattern.left, visit);
-    return;
-  }
-  if (pattern.type === "RestElement") {
-    visit_topmost_lazy_patterns(pattern.argument, visit);
-    return;
-  }
-  if (pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") return;
-  if (pattern.lazy) {
-    visit(pattern);
-    return;
-  }
-  if (pattern.type === "ObjectPattern") {
-    for (const prop2 of pattern.properties) {
-      if (prop2.type === "RestElement") visit_topmost_lazy_patterns(prop2.argument, visit);
-      else visit_topmost_lazy_patterns(prop2.value, visit);
-    }
-  } else {
-    for (const element of pattern.elements) {
-      if (element) visit_topmost_lazy_patterns(element, visit);
-    }
-  }
-}
-function build_lazy_id_for_pattern(pattern, lazy_id_name, is_top) {
-  const pattern_range = get_lazy_pattern_mapping_range(pattern);
-  const lazy_id = pattern_range ? create_generated_identifier2(
-    lazy_id_name,
-    pattern_range,
-    void 0,
-    pattern_range.source_length
-  ) : create_generated_identifier2(lazy_id_name);
-  if (!is_top) return lazy_id;
-  if (pattern.typeAnnotation) {
-    lazy_id.typeAnnotation = pattern.typeAnnotation;
-  }
-  set_lazy_param_binding_mappings(lazy_id, pattern);
-  return lazy_id;
-}
-function replace_lazy_in_pattern(pattern, is_top = true) {
-  if (!pattern || typeof pattern !== "object") return pattern;
-  if (pattern.type === "AssignmentPattern") {
-    const new_left = replace_lazy_in_pattern(pattern.left, is_top);
-    return new_left === pattern.left ? pattern : { ...pattern, left: new_left };
-  }
-  if (pattern.type === "RestElement") {
-    const new_arg = replace_lazy_in_pattern(pattern.argument, false);
-    return new_arg === pattern.argument ? pattern : { ...pattern, argument: new_arg };
-  }
-  if (pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") return pattern;
-  const lazy_id = pattern.metadata?.lazy_id;
-  if (pattern.lazy && lazy_id) {
-    return build_lazy_id_for_pattern(pattern, lazy_id, is_top);
-  }
-  if (pattern.type === "ObjectPattern") {
-    let changed2 = false;
-    const new_properties = pattern.properties.map((prop2) => {
-      if (prop2.type === "RestElement") {
-        const new_arg = replace_lazy_in_pattern(prop2.argument, false);
-        if (new_arg === prop2.argument) return prop2;
-        changed2 = true;
-        return { ...prop2, argument: new_arg };
-      }
-      const new_value = replace_lazy_in_pattern(prop2.value, false);
-      if (new_value === prop2.value) return prop2;
-      changed2 = true;
-      return { ...prop2, value: new_value };
-    });
-    return changed2 ? { ...pattern, properties: new_properties } : pattern;
-  }
-  let changed = false;
-  const new_elements = pattern.elements.map((element) => {
-    if (!element) return element;
-    const new_element = replace_lazy_in_pattern(element, false);
-    if (new_element !== element) changed = true;
-    return new_element;
-  });
-  return changed ? { ...pattern, elements: new_elements } : pattern;
-}
-function transform_loop_pattern_expressions(pattern, lazy_bindings) {
-  if (!pattern || typeof pattern !== "object") return pattern;
-  if (pattern.type === "AssignmentPattern") {
-    const new_left = transform_loop_pattern_expressions(pattern.left, lazy_bindings);
-    const new_right = apply_lazy_transforms_to_slot(pattern.right, lazy_bindings);
-    return new_left !== pattern.left || new_right !== pattern.right ? (
-      /** @type {T} */
-      { ...pattern, left: new_left, right: new_right }
-    ) : pattern;
-  }
-  if (pattern.type === "RestElement") {
-    const new_argument = transform_loop_pattern_expressions(pattern.argument, lazy_bindings);
-    return new_argument === pattern.argument ? pattern : (
-      /** @type {T} */
-      { ...pattern, argument: new_argument }
-    );
-  }
-  if (pattern.type === "ObjectPattern") {
-    let changed = false;
-    const properties = pattern.properties.map((property) => {
-      if (property.type === "RestElement") {
-        const new_argument = transform_loop_pattern_expressions(property.argument, lazy_bindings);
-        if (new_argument === property.argument) return property;
-        changed = true;
-        return rebuild(property, { argument: new_argument });
-      }
-      const new_key = property.computed ? apply_lazy_transforms_to_slot(property.key, lazy_bindings) : property.key;
-      const new_value = transform_loop_pattern_expressions(property.value, lazy_bindings);
-      if (new_key === property.key && new_value === property.value) return property;
-      changed = true;
-      return rebuild(property, { key: new_key, value: new_value });
-    });
-    return changed ? (
-      /** @type {T} */
-      { ...pattern, properties }
-    ) : pattern;
-  }
-  if (pattern.type === "ArrayPattern") {
-    let changed = false;
-    const elements = pattern.elements.map((element) => {
-      if (!element) return element;
-      const new_element = transform_loop_pattern_expressions(element, lazy_bindings);
-      if (new_element !== element) changed = true;
-      return new_element;
-    });
-    return changed ? (
-      /** @type {T} */
-      { ...pattern, elements }
-    ) : pattern;
-  }
-  return pattern;
-}
-function preallocate_lazy_ids(root, context, assignments_only = false) {
-  const HAS_LAZY = 1;
-  const HAS_VAR_LOOP = 2;
-  const path = [];
-  const assign_id = (pattern) => {
-    visit_topmost_lazy_patterns(pattern, (lazy) => {
-      if (lazy.metadata?.lazy_id) return;
-      lazy.metadata = { ...lazy.metadata, lazy_id: generate_lazy_id(context) };
-    });
-  };
-  const has_preallocated_lazy_binding = (pattern) => {
-    let found = false;
-    visit_topmost_lazy_patterns(pattern, (lazy) => {
-      if (lazy.metadata?.lazy_id) found = true;
-    });
-    return found;
-  };
-  const visit = (value) => {
-    if (!value || typeof value !== "object") return 0;
-    if (Array.isArray(value)) {
-      let flags2 = 0;
-      for (const child of value) {
-        flags2 |= visit(child);
-      }
-      return flags2;
-    }
-    if (!is_ast_node(value)) return 0;
-    const node = value;
-    const is_function_like = is_function_or_component_node(node);
-    if (is_function_like && !assignments_only) {
-      for (const param of node.params) {
-        assign_id(param.type === "AssignmentPattern" ? param.left : param);
-      }
-    }
-    if (node.type === "VariableDeclarator" && !assignments_only) {
-      assign_id(node.id);
-    }
-    if ((node.type === "ForOfStatement" || node.type === "ForInStatement") && node.left.type !== "VariableDeclaration") {
-      assign_id(node.left);
-    }
-    if (node.type === "AssignmentExpression" && is_supported_lazy_assignment_position(node, path)) {
-      assign_id(node.left);
-    }
-    let flags = (node.type === "ObjectPattern" || node.type === "ArrayPattern") && node.lazy === true ? HAS_LAZY : 0;
-    const entries = (
-      /** @type {AST.TraversableAstNode} */
-      node
-    );
-    path.push(node);
-    for (const key2 of Object.keys(entries)) {
-      if (key2 === "loc" || key2 === "start" || key2 === "end" || key2 === "metadata") continue;
-      flags |= visit(entries[key2]);
-    }
-    path.pop();
-    const loop_declaration = node.type === "ForStatement" ? node.init : node.type === "ForOfStatement" || node.type === "ForInStatement" ? node.left : null;
-    if (loop_declaration?.type === "VariableDeclaration" && loop_declaration.kind === "var" && loop_declaration.declarations.some(
-      (declarator2) => has_preallocated_lazy_binding(declarator2.id)
-    )) {
-      flags |= HAS_VAR_LOOP;
-    }
-    if (is_function_like) {
-      if (flags & HAS_LAZY) {
-        node.metadata = { ...node.metadata, has_lazy_descendants: true };
-      }
-      if (flags & HAS_VAR_LOOP) {
-        node.metadata = { ...node.metadata, has_lazy_var_loop_descendants: true };
-      }
-      flags &= ~HAS_VAR_LOOP;
-    } else if (node.type === "StaticBlock") {
-      if (flags & HAS_VAR_LOOP) {
-        node.metadata = { ...node.metadata, has_lazy_var_loop_descendants: true };
-      }
-      flags &= ~HAS_VAR_LOOP;
-    } else if (flags & HAS_VAR_LOOP) {
-      node.metadata = { ...node.metadata, has_lazy_var_loop_descendants: true };
-    }
-    return flags;
-  };
-  visit(root);
-}
-function estree_member_to_jsx_name(expr, source) {
-  if (expr.type === "Identifier") {
-    return set_source_location(jsx_id(expr.name), source);
-  }
-  if (expr.type === "MemberExpression" && !expr.computed && expr.property.type === "Identifier") {
-    const object3 = estree_member_to_jsx_name(expr.object, source);
-    if (!object3) return null;
-    return set_source_location(jsx_member(object3, jsx_id(expr.property.name)), source);
-  }
-  return null;
-}
-function rewrite_lazy_jsx_name(name, lazy_bindings) {
-  if (!name) return null;
-  if (name.type === "JSXIdentifier") {
-    const binding = lazy_bindings.get(name.name);
-    if (!binding) return null;
-    return estree_member_to_jsx_name(binding.read(name), name);
-  }
-  if (name.type === "JSXMemberExpression") {
-    const new_object = rewrite_lazy_jsx_name(name.object, lazy_bindings);
-    return new_object ? { ...name, object: new_object } : null;
-  }
-  return null;
-}
-function apply_lazy_transforms_to_value(value, lazy_bindings) {
-  if (Array.isArray(value)) {
-    return value.map((child) => apply_lazy_transforms_to_value(child, lazy_bindings));
-  }
-  if (!is_ast_node(value)) return value;
-  return apply_lazy_transforms(value, lazy_bindings);
-}
-function rebuild(node, changes) {
-  return (
-    /** @type {T} */
-    { ...node, ...changes }
-  );
-}
-function apply_lazy_transforms_to_slot(node, lazy_bindings) {
-  return (
-    /** @type {T} */
-    apply_lazy_transforms(node, lazy_bindings)
-  );
-}
-function collect_preallocated_lazy_bindings(pattern, lazy_bindings) {
-  visit_topmost_lazy_patterns(pattern, (lazy) => {
-    if (!lazy.metadata?.lazy_id) return;
-    collect_lazy_bindings(lazy, lazy.metadata.lazy_id, lazy_bindings);
-  });
-}
-function collect_statement_var_loop_bindings(node, lazy_bindings) {
-  if (is_function_or_component_node(node) || node.type === "StaticBlock") return;
-  if (node.type === "ForStatement" && node.init?.type === "VariableDeclaration" && node.init.kind === "var") {
-    for (const declarator2 of node.init.declarations) {
-      collect_preallocated_lazy_bindings(declarator2.id, lazy_bindings);
-    }
-  } else if ((node.type === "ForOfStatement" || node.type === "ForInStatement") && node.left.type === "VariableDeclaration" && node.left.kind === "var") {
-    for (const declarator2 of node.left.declarations) {
-      collect_preallocated_lazy_bindings(declarator2.id, lazy_bindings);
-    }
-  }
-  for (const child of child_nodes(node)) {
-    collect_statement_var_loop_bindings(child, lazy_bindings);
-  }
-}
-function advance_statement_var_loop_bindings(node, lazy_bindings) {
-  if (!node.metadata?.has_lazy_var_loop_descendants) return lazy_bindings;
-  const statement_bindings = /* @__PURE__ */ new Map();
-  collect_statement_var_loop_bindings(node, statement_bindings);
-  return statement_bindings.size > 0 ? new Map([...lazy_bindings, ...statement_bindings]) : lazy_bindings;
-}
-function transform_statement_list(statements, lazy_bindings, has_lazy_var_loop_descendants) {
-  let effective_bindings = lazy_bindings;
-  let changed = false;
-  const body = statements.map((statement) => {
-    const transformed = apply_lazy_transforms_to_slot(statement, effective_bindings);
-    if (transformed !== statement) changed = true;
-    if (has_lazy_var_loop_descendants && statement.metadata?.has_lazy_var_loop_descendants) {
-      effective_bindings = advance_statement_var_loop_bindings(statement, effective_bindings);
-    }
-    return transformed;
-  });
-  return { body, lazy_bindings: effective_bindings, changed };
-}
-function transform_classic_for_declaration(declaration2, lazy_bindings) {
-  let effective_bindings = lazy_bindings;
-  let mutable_bindings = null;
-  let changed = false;
-  const declarations = declaration2.declarations.map((declarator2) => {
-    const new_init = declarator2.init && apply_lazy_transforms_to_slot(declarator2.init, effective_bindings);
-    const expression_id = transform_loop_pattern_expressions(declarator2.id, effective_bindings);
-    const new_id = replace_lazy_in_pattern(expression_id);
-    if (new_init !== declarator2.init || new_id !== declarator2.id) changed = true;
-    const own_bindings = /* @__PURE__ */ new Map();
-    collect_preallocated_lazy_bindings(expression_id, own_bindings);
-    if (own_bindings.size > 0) {
-      mutable_bindings ??= new Map(effective_bindings);
-      for (const [name, binding] of own_bindings) mutable_bindings.set(name, binding);
-      effective_bindings = mutable_bindings;
-    }
-    return new_init !== declarator2.init || new_id !== declarator2.id ? rebuild(declarator2, { id: new_id, init: new_init }) : declarator2;
-  });
-  return {
-    declaration: changed ? rebuild(declaration2, { declarations }) : declaration2,
-    lazy_bindings: effective_bindings
-  };
-}
-function transform_for_each_left(left, lazy_bindings) {
-  const own_bindings = /* @__PURE__ */ new Map();
-  if (left.type === "VariableDeclaration") {
-    let changed = false;
-    const declarations = left.declarations.map((declarator2) => {
-      const expression_id = transform_loop_pattern_expressions(declarator2.id, lazy_bindings);
-      collect_preallocated_lazy_bindings(expression_id, own_bindings);
-      const new_id2 = replace_lazy_in_pattern(expression_id);
-      if (new_id2 === declarator2.id) return declarator2;
-      changed = true;
-      return rebuild(declarator2, { id: new_id2 });
-    });
-    return {
-      left: changed ? rebuild(left, { declarations }) : left,
-      lazy_bindings: own_bindings
-    };
-  }
-  const expression_left = transform_loop_pattern_expressions(left, lazy_bindings);
-  collect_preallocated_lazy_bindings(expression_left, own_bindings);
-  if (own_bindings.size === 0) return { left: expression_left, lazy_bindings: own_bindings };
-  const new_id = replace_lazy_in_pattern(expression_left);
-  return {
-    left: declaration("const", [declarator(new_id)]),
-    lazy_bindings: own_bindings
-  };
-}
-function apply_lazy_transforms(node, lazy_bindings) {
-  if (!node || typeof node !== "object") return node;
-  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-    let params_changed = false;
-    const new_params = node.params.map((param) => {
-      const transformed = transform_param_defaults(param, lazy_bindings);
-      if (transformed !== param) params_changed = true;
-      return transformed;
-    });
-    const shadowed = /* @__PURE__ */ new Set();
-    for (const param of node.params) {
-      collect_shadowed_names(param, lazy_bindings, shadowed);
-    }
-    const outer_minus_shadow = shadowed.size > 0 ? remove_shadowed(lazy_bindings, shadowed) : lazy_bindings;
-    const own_bindings = /* @__PURE__ */ new Map();
-    let had_lazy_param = false;
-    for (const param of node.params) {
-      visit_topmost_lazy_patterns(param, (lazy) => {
-        if (!lazy.metadata?.lazy_id) return;
-        had_lazy_param = true;
-        collect_lazy_bindings(lazy, lazy.metadata.lazy_id, own_bindings);
-      });
-    }
-    const inner_bindings = own_bindings.size > 0 ? new Map([...outer_minus_shadow, ...own_bindings]) : outer_minus_shadow;
-    if (inner_bindings.size === 0 && !params_changed && !had_lazy_param && !node.metadata?.has_lazy_descendants) {
-      return node;
-    }
-    const new_body = apply_lazy_transforms_to_slot(node.body, inner_bindings);
-    const final_params_src = params_changed ? new_params : node.params;
-    const final_params = had_lazy_param ? replace_lazy_params(final_params_src) : final_params_src;
-    if (new_body !== node.body || final_params !== node.params) {
-      return rebuild(node, { params: final_params, body: new_body });
-    }
-    return node;
-  }
-  if (node.type === "BlockStatement" || node.type === "Program" || node.type === "StaticBlock") {
-    const body = node.body;
-    const block_bindings = collect_block_shadowed_names(body, lazy_bindings);
-    const after_shadow = block_bindings.size > 0 ? remove_shadowed(lazy_bindings, block_bindings) : lazy_bindings;
-    const block_lazy = /* @__PURE__ */ new Map();
-    collect_lazy_bindings_from_statements(body, block_lazy);
-    const initial_bindings = block_lazy.size > 0 ? new Map([...after_shadow, ...block_lazy]) : after_shadow;
-    const transformed = transform_statement_list(
-      node.body,
-      initial_bindings,
-      node.metadata?.has_lazy_var_loop_descendants === true
-    );
-    return transformed.changed ? rebuild(node, { body: transformed.body }) : node;
-  }
-  if (node.type === "CatchClause") {
-    const shadowed = /* @__PURE__ */ new Set();
-    if (node.param) collect_shadowed_names(node.param, lazy_bindings, shadowed);
-    const effective_bindings = shadowed.size > 0 ? remove_shadowed(lazy_bindings, shadowed) : lazy_bindings;
-    const new_body = apply_lazy_transforms_to_slot(node.body, effective_bindings);
-    if (new_body !== node.body) return rebuild(node, { body: new_body });
-    return node;
-  }
-  if (node.type === "DoWhileStatement") {
-    const new_body = apply_lazy_transforms_to_slot(node.body, lazy_bindings);
-    const test_bindings = advance_statement_var_loop_bindings(node.body, lazy_bindings);
-    const new_test = apply_lazy_transforms_to_slot(node.test, test_bindings);
-    if (new_body !== node.body || new_test !== node.test) {
-      return rebuild(node, { body: new_body, test: new_test });
-    }
-    return node;
-  }
-  if (node.type === "IfStatement") {
-    const new_test = apply_lazy_transforms_to_slot(node.test, lazy_bindings);
-    const new_consequent = apply_lazy_transforms_to_slot(node.consequent, lazy_bindings);
-    const alternate_bindings = advance_statement_var_loop_bindings(node.consequent, lazy_bindings);
-    const new_alternate = node.alternate && apply_lazy_transforms_to_slot(node.alternate, alternate_bindings);
-    if (new_test !== node.test || new_consequent !== node.consequent || new_alternate !== node.alternate) {
-      return rebuild(node, {
-        test: new_test,
-        consequent: new_consequent,
-        alternate: new_alternate
-      });
-    }
-    return node;
-  }
-  if (node.type === "TryStatement") {
-    const new_block = apply_lazy_transforms_to_slot(node.block, lazy_bindings);
-    const handler_bindings = advance_statement_var_loop_bindings(node.block, lazy_bindings);
-    const new_handler = node.handler && apply_lazy_transforms_to_slot(node.handler, handler_bindings);
-    const finalizer_bindings = node.handler ? advance_statement_var_loop_bindings(node.handler, handler_bindings) : handler_bindings;
-    const new_finalizer = node.finalizer && apply_lazy_transforms_to_slot(node.finalizer, finalizer_bindings);
-    if (new_block !== node.block || new_handler !== node.handler || new_finalizer !== node.finalizer) {
-      return rebuild(node, {
-        block: new_block,
-        handler: new_handler,
-        finalizer: new_finalizer
-      });
-    }
-    return node;
-  }
-  if (node.type === "ForStatement") {
-    const shadowed = /* @__PURE__ */ new Set();
-    if (node.init?.type === "VariableDeclaration") {
-      for (const decl of node.init.declarations) {
-        if (decl.id) collect_non_lazy_shadowed_names(decl.id, lazy_bindings, shadowed);
-      }
-    }
-    let effective_bindings = shadowed.size > 0 ? remove_shadowed(lazy_bindings, shadowed) : lazy_bindings;
-    let changed2 = false;
-    let new_init = node.init;
-    if (node.init?.type === "VariableDeclaration") {
-      const transformed = transform_classic_for_declaration(node.init, effective_bindings);
-      new_init = transformed.declaration;
-      effective_bindings = transformed.lazy_bindings;
-    } else if (node.init) {
-      new_init = apply_lazy_transforms_to_slot(node.init, effective_bindings);
-    }
-    if (new_init !== node.init) changed2 = true;
-    const new_test = node.test && apply_lazy_transforms_to_slot(node.test, effective_bindings);
-    if (new_test !== node.test) changed2 = true;
-    const new_update = node.update && apply_lazy_transforms_to_slot(node.update, effective_bindings);
-    if (new_update !== node.update) changed2 = true;
-    const new_body = apply_lazy_transforms_to_slot(node.body, effective_bindings);
-    if (new_body !== node.body) changed2 = true;
-    return changed2 ? rebuild(node, { init: new_init, test: new_test, update: new_update, body: new_body }) : node;
-  }
-  if (node.type === "ForOfStatement" || node.type === "ForInStatement") {
-    const shadowed = /* @__PURE__ */ new Set();
-    if (node.left?.type === "VariableDeclaration") {
-      for (const decl of node.left.declarations) {
-        if (decl.id) collect_shadowed_names(decl.id, lazy_bindings, shadowed);
-      }
-    } else {
-      collect_shadowed_names(node.left, lazy_bindings, shadowed);
-    }
-    const after_shadow = shadowed.size > 0 ? remove_shadowed(lazy_bindings, shadowed) : lazy_bindings;
-    const transformed_left = transform_for_each_left(node.left, after_shadow);
-    const effective_bindings = transformed_left.lazy_bindings.size > 0 ? new Map([...after_shadow, ...transformed_left.lazy_bindings]) : after_shadow;
-    let changed2 = false;
-    if (transformed_left.left !== node.left) changed2 = true;
-    const new_right = apply_lazy_transforms_to_slot(node.right, lazy_bindings);
-    if (new_right !== node.right) changed2 = true;
-    const new_body = apply_lazy_transforms_to_slot(node.body, effective_bindings);
-    if (new_body !== node.body) changed2 = true;
-    return changed2 ? rebuild(node, { left: transformed_left.left, right: new_right, body: new_body }) : node;
-  }
-  if (node.type === "SwitchStatement") {
-    const all_consequents = node.cases.flatMap((switch_case2) => switch_case2.consequent);
-    const block_shadowed = collect_block_shadowed_names(all_consequents, lazy_bindings);
-    const after_shadow = block_shadowed.size > 0 ? remove_shadowed(lazy_bindings, block_shadowed) : lazy_bindings;
-    const block_lazy = /* @__PURE__ */ new Map();
-    collect_lazy_bindings_from_statements(all_consequents, block_lazy);
-    const effective_bindings = block_lazy.size > 0 ? new Map([...after_shadow, ...block_lazy]) : after_shadow;
-    let changed2 = false;
-    const new_discriminant = apply_lazy_transforms_to_slot(node.discriminant, after_shadow);
-    if (new_discriminant !== node.discriminant) changed2 = true;
-    let consequent_bindings = effective_bindings;
-    const new_cases = node.cases.map((switch_case2) => {
-      let case_changed = false;
-      const new_test = switch_case2.test ? apply_lazy_transforms_to_slot(switch_case2.test, effective_bindings) : null;
-      if (new_test !== switch_case2.test) case_changed = true;
-      const transformed = transform_statement_list(
-        switch_case2.consequent,
-        consequent_bindings,
-        node.metadata?.has_lazy_var_loop_descendants === true
-      );
-      consequent_bindings = transformed.lazy_bindings;
-      if (transformed.changed) case_changed = true;
-      if (case_changed) {
-        changed2 = true;
-        return rebuild(switch_case2, { test: new_test, consequent: transformed.body });
-      }
-      return switch_case2;
-    });
-    return changed2 ? rebuild(node, { discriminant: new_discriminant, cases: new_cases }) : node;
-  }
-  if (node.type === "ExpressionStatement") {
-    const assignment2 = get_standalone_assignment(node);
-    const pattern = assignment2?.left;
-    if (assignment2?.operator === "=" && (pattern?.type === "ObjectPattern" || pattern?.type === "ArrayPattern") && pattern.lazy) {
-      const lazy_id_name = pattern.metadata?.lazy_id;
-      if (lazy_id_name !== void 0) {
-        const lazy_id = build_lazy_id_for_pattern(pattern, lazy_id_name, false);
-        if (pattern.typeAnnotation) lazy_id.typeAnnotation = pattern.typeAnnotation;
-        const init2 = apply_lazy_transforms_to_slot(assignment2.right, lazy_bindings);
-        return const_builder(lazy_id, init2);
-      }
-    }
-  }
-  if (node.type === "ExpressionStatement" && node.expression?.type === "AssignmentExpression" && node.expression.operator === "=" && (node.expression.left?.type === "ObjectPattern" || node.expression.left?.type === "ArrayPattern") && !node.expression.left.lazy) {
-    const new_left = replace_lazy_in_pattern(node.expression.left);
-    if (new_left !== node.expression.left) {
-      return {
-        ...node,
-        expression: {
-          ...node.expression,
-          left: new_left,
-          right: apply_lazy_transforms_to_slot(node.expression.right, lazy_bindings)
-        }
-      };
-    }
-  }
-  if (node.type === "AssignmentExpression" && node.operator === "=" && (node.left.type === "ObjectPattern" || node.left.type === "ArrayPattern") && node.left.lazy && !node.left.metadata?.lazy_id) {
-    const new_right = apply_lazy_transforms_to_slot(node.right, lazy_bindings);
-    const recovered = new_right === node.right ? node : { ...node, right: new_right };
-    return parenthesized(recovered, has_location(node) ? node : void 0);
-  }
-  if (node.type === "AssignmentExpression" && node.left?.type === "Identifier" && lazy_bindings.has(node.left.name)) {
-    const binding = (
-      /** @type {LazyBinding} */
-      lazy_bindings.get(node.left.name)
-    );
-    return {
-      ...node,
-      left: binding.read(node.left),
-      right: apply_lazy_transforms_to_slot(node.right, lazy_bindings)
-    };
-  }
-  if (node.type === "UpdateExpression" && node.argument?.type === "Identifier" && lazy_bindings.has(node.argument.name)) {
-    const binding = (
-      /** @type {LazyBinding} */
-      lazy_bindings.get(node.argument.name)
-    );
-    return { ...node, argument: binding.read(node.argument) };
-  }
-  if (node.type === "VariableDeclarator" && node.id?.metadata?.lazy_id) {
-    const lazy_id = create_generated_identifier2(node.id.metadata.lazy_id);
-    if (node.id.typeAnnotation) lazy_id.typeAnnotation = node.id.typeAnnotation;
-    return {
-      ...node,
-      id: lazy_id,
-      init: node.init && apply_lazy_transforms_to_slot(node.init, lazy_bindings)
-    };
-  }
-  if (node.type === "VariableDeclarator" && (node.id?.type === "ObjectPattern" || node.id?.type === "ArrayPattern") && !node.id.lazy) {
-    const new_id = replace_lazy_in_pattern(node.id);
-    if (new_id !== node.id) {
-      return {
-        ...node,
-        id: new_id,
-        init: node.init && apply_lazy_transforms_to_slot(node.init, lazy_bindings)
-      };
-    }
-  }
-  if (node.type === "Property" && node.shorthand && node.value?.type === "Identifier") {
-    const binding = lazy_bindings.get(node.value.name);
-    if (binding) {
-      return { ...node, shorthand: false, value: binding.read(node.value) };
-    }
-  }
-  if (node.type === "Identifier" && lazy_bindings.has(node.name)) {
-    const binding = (
-      /** @type {LazyBinding} */
-      lazy_bindings.get(node.name)
-    );
-    return binding.read(node);
-  }
-  if (node.type === "JSXIdentifier") return node;
-  let changed = false;
-  const entries = (
-    /** @type {AST.TraversableAstNode} */
-    node
-  );
-  const clone = { ...entries };
-  for (const key2 of Object.keys(entries)) {
-    if (key2 === "loc" || key2 === "start" || key2 === "end" || key2 === "metadata") continue;
-    if (key2 === "key" && node.type === "Property" && !node.computed && !node.shorthand) continue;
-    if (key2 === "property" && node.type === "MemberExpression" && !node.computed) continue;
-    if (key2 === "property" && node.type === "JSXMemberExpression") continue;
-    if (key2 === "name" && node.type === "JSXAttribute") continue;
-    if (key2 === "id" && node.type === "VariableDeclarator") continue;
-    if (key2 === "name" && (node.type === "JSXOpeningElement" || node.type === "JSXClosingElement")) {
-      const jsx_name = rewrite_lazy_jsx_name(node.name, lazy_bindings);
-      if (jsx_name) {
-        clone[key2] = jsx_name;
-        changed = true;
-        continue;
-      }
-    }
-    const new_value = apply_lazy_transforms_to_value(entries[key2], lazy_bindings);
-    if (new_value !== entries[key2]) {
-      clone[key2] = new_value;
-      changed = true;
-    }
-  }
-  return changed ? (
-    /** @type {AST.Node} */
-    clone
-  ) : node;
-}
-function transform_param_defaults(param, lazy_bindings) {
-  if (param.type === "AssignmentPattern") {
-    const new_right = apply_lazy_transforms_to_slot(param.right, lazy_bindings);
-    if (new_right !== param.right) return { ...param, right: new_right };
-  }
-  return param;
-}
-function collect_shadowed_names(pattern, lazy_bindings, shadowed) {
-  if (!pattern || typeof pattern !== "object") return;
-  if (pattern.type === "Identifier" && lazy_bindings.has(pattern.name)) {
-    shadowed.add(pattern.name);
-    return;
-  }
-  if (pattern.type === "AssignmentPattern") {
-    collect_shadowed_names(pattern.left, lazy_bindings, shadowed);
-    return;
-  }
-  if (pattern.type === "RestElement") {
-    collect_shadowed_names(pattern.argument, lazy_bindings, shadowed);
-    return;
-  }
-  if (pattern.type === "ObjectPattern") {
-    for (const prop2 of pattern.properties) {
-      if (prop2.type === "RestElement") {
-        collect_shadowed_names(prop2.argument, lazy_bindings, shadowed);
-      } else {
-        collect_shadowed_names(prop2.value, lazy_bindings, shadowed);
-      }
-    }
-    return;
-  }
-  if (pattern.type === "ArrayPattern") {
-    for (const element of pattern.elements) {
-      if (element) collect_shadowed_names(element, lazy_bindings, shadowed);
-    }
-  }
-}
-function collect_non_lazy_shadowed_names(pattern, lazy_bindings, shadowed) {
-  if (!pattern || typeof pattern !== "object") return;
-  if ((pattern.type === "ObjectPattern" || pattern.type === "ArrayPattern") && pattern.lazy) {
-    return;
-  }
-  if (pattern.type === "Identifier" && lazy_bindings.has(pattern.name)) {
-    shadowed.add(pattern.name);
-    return;
-  }
-  if (pattern.type === "AssignmentPattern") {
-    collect_non_lazy_shadowed_names(pattern.left, lazy_bindings, shadowed);
-    return;
-  }
-  if (pattern.type === "RestElement") {
-    collect_non_lazy_shadowed_names(pattern.argument, lazy_bindings, shadowed);
-    return;
-  }
-  if (pattern.type === "ObjectPattern") {
-    for (const prop2 of pattern.properties) {
-      collect_non_lazy_shadowed_names(
-        prop2.type === "RestElement" ? prop2.argument : prop2.value,
-        lazy_bindings,
-        shadowed
-      );
-    }
-    return;
-  }
-  if (pattern.type === "ArrayPattern") {
-    for (const element of pattern.elements) {
-      if (element) collect_non_lazy_shadowed_names(element, lazy_bindings, shadowed);
-    }
-  }
-}
-function collect_block_shadowed_names(statements, lazy_bindings) {
-  const shadowed = /* @__PURE__ */ new Set();
-  for (const stmt2 of statements) {
-    if (stmt2.type === "VariableDeclaration") {
-      for (const decl of stmt2.declarations) {
-        if (decl.id.metadata?.lazy_id) continue;
-        collect_shadowed_names(decl.id, lazy_bindings, shadowed);
-      }
-    } else if (stmt2.type === "FunctionDeclaration" && stmt2.id) {
-      if (lazy_bindings.has(stmt2.id.name)) shadowed.add(stmt2.id.name);
-    }
-  }
-  return shadowed;
-}
-function remove_shadowed(lazy_bindings, shadowed) {
-  const result = new Map(lazy_bindings);
-  for (const name of shadowed) result.delete(name);
-  return result;
-}
-function replace_lazy_params(params) {
-  return params.map((param) => {
-    if (param.type === "AssignmentPattern") {
-      const new_left = replace_lazy_in_pattern(param.left);
-      return new_left === param.left ? param : { ...param, left: new_left };
-    }
-    return replace_lazy_in_pattern(param);
-  });
-}
-
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/await.js
-function find_first_top_level_await_in_tsrx_function_body(body_nodes) {
-  for (const node of body_nodes) {
-    const found = find_first_top_level_await(node, false);
-    if (found) return found;
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/await.js
+function find_first_top_level_await_in_tsrx_function_body(body_nodes) {
+  for (const node of body_nodes) {
+    const found = find_first_top_level_await(node, false);
+    if (found) return found;
   }
   return null;
 }
@@ -24925,7 +24149,7 @@ function find_first_top_level_await(node, inside_nested_function) {
   return null;
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/scoping.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/scoping.js
 function prepare_stylesheet_for_render(stylesheet, mode = "scope") {
   const render_mode = mode === true ? "class-map" : mode === false ? "scope" : mode;
   const is_class_map = render_mode === "class-map";
@@ -24995,17 +24219,17 @@ function class_attribute_base(attr) {
 function build_scope_class_value(parts) {
   const { base, hashes, applied } = parts;
   const base_literal = base?.type === "Literal" && typeof base.value === "string" ? base : null;
-  const sequence = [];
-  if (base_literal) sequence.push(
+  const sequence2 = [];
+  if (base_literal) sequence2.push(
     /** @type {string} */
     base_literal.value
   );
-  else if (base) sequence.push(base);
-  sequence.push(...hashes, ...applied);
+  else if (base) sequence2.push(base);
+  sequence2.push(...hashes, ...applied);
   const quasis = [];
   const expressions = [];
   let text = "";
-  for (const part of sequence) {
+  for (const part of sequence2) {
     if (typeof part === "string") {
       if (part) text = text ? `${text} ${part}` : part;
       continue;
@@ -25055,7 +24279,7 @@ function add_scope_classes(element, hashes, applied, class_attr_name = "class")
   };
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/analyze/prune.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/analyze/prune.js
 var regex_backslash_and_following_character2 = /\\(.)/g;
 var FORWARD = 0;
 var BACKWARD = 1;
@@ -25554,7 +24778,7 @@ function relative_selector_might_apply_to_node(relative_selector, rule, element,
       );
       let matched = false;
       for (const complex_selector of complex_selectors) {
-        const [first, ...rest] = truncate(complex_selector);
+        const [first, ...rest2] = truncate(complex_selector);
         if (!first) {
           complex_selector.metadata.used = true;
           matched = true;
@@ -25563,7 +24787,7 @@ function relative_selector_might_apply_to_node(relative_selector, rule, element,
         if (include_self) {
           const selector_including_self = [
             first.combinator ? { ...first, combinator: null } : first,
-            ...rest
+            ...rest2
           ];
           if (apply_selector(selector_including_self, rule, element, FORWARD)) {
             complex_selector.metadata.used = true;
@@ -25573,7 +24797,7 @@ function relative_selector_might_apply_to_node(relative_selector, rule, element,
         const selector_excluding_self = [
           create_any_selector(first.start, first.end),
           first.combinator ? first : { ...first, combinator: create_descendant_combinator(first.start, first.end) },
-          ...rest
+          ...rest2
         ];
         if (apply_selector(selector_excluding_self, rule, element, FORWARD)) {
           complex_selector.metadata.used = true;
@@ -25779,7 +25003,7 @@ function prune_css(css, element, styleClasses, topScopedClasses, regionHash = cs
   walk(css, null, visitors3);
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/jsx/style-scopes.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/jsx/style-scopes.js
 function prepare_style_scopes(program, ctx) {
   const state = {
     ctx,
@@ -26249,7 +25473,7 @@ function type_only_style(block2) {
   };
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/jsx-interleave.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/jsx-interleave.js
 function is_interleaved_body(body_nodes, is_jsx_child2) {
   let seen_jsx = false;
   for (const child of body_nodes) {
@@ -26276,7 +25500,7 @@ function capture_jsx_child(jsx, capture_index, anchor_id) {
   return { declaration: declaration2, reference };
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/jsx-hoist.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/jsx-hoist.js
 function is_static_literal(node) {
   return node.value === null || typeof node.value === "string" || typeof node.value === "number" || typeof node.value === "boolean" || typeof node.value === "bigint";
 }
@@ -26342,7 +25566,7 @@ function is_hoist_safe_jsx_node(node) {
   return node.openingElement.attributes.every(is_hoist_safe_jsx_attribute) && node.children.every(is_hoist_safe_jsx_child);
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/jsx/server-module.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/jsx/server-module.js
 var HOISTED_IMPORT_PREFIX = "__tsrx_server_import$";
 var WALK_SKIP_KEYS = /* @__PURE__ */ new Set([
   "loc",
@@ -26520,11 +25744,11 @@ function lower_colliding_import(statement, hoisted_name) {
 function lower_declaration(declaration2, outside_names, block_name) {
   const hoisted_imports = [];
   const aliases = [];
-  const rest = [];
+  const rest2 = [];
   let hoisted_index = 0;
   for (const statement of declaration2.body?.body ?? []) {
     if (statement.type !== "ImportDeclaration") {
-      rest.push(statement);
+      rest2.push(statement);
       continue;
     }
     const collides = statement.specifiers.some(
@@ -26546,7 +25770,7 @@ function lower_declaration(declaration2, outside_names, block_name) {
       id: id2,
       kind: "namespace",
       metadata: { ...declaration2.metadata, module_keyword: "namespace" },
-      body: { ...declaration2.body, body: [...aliases, ...rest] }
+      body: { ...declaration2.body, body: [...aliases, ...rest2] }
     }
   );
   return [...hoisted_imports, namespace];
@@ -26606,7 +25830,7 @@ function lower_server_module_for_types(ast, server_module) {
   ) };
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/jsx/index.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/jsx/index.js
 var TEMPLATE_FRAGMENT_ERROR = "JSX fragment syntax is not needed in TSRX templates. TSRX renders in immediate mode, so everything is already a fragment. Use `<>...</>` only in expression position.";
 var TSRX_FOR_RETURN_ERROR = "Return statements are not allowed inside TSRX template for...of loops. Filter the iterable before rendering or use an @empty fallback for empty lists.";
 var TSRX_FOR_BREAK_ERROR = "Break statements are not allowed inside TSRX template for...of loops.";
@@ -26673,14 +25897,14 @@ function expand_child_code_blocks(node, seen = /* @__PURE__ */ new Set()) {
     node
   );
   let out = source;
-  const set = (key2, value) => {
+  const set2 = (key2, value) => {
     if (out[key2] === value) return;
     if (out === source) out = { ...source };
     out[key2] = value;
   };
   const children = source.children;
   if (Array.isArray(children) && children.some((c) => is_ast_node(c) && c.type === "JSXCodeBlock")) {
-    set(
+    set2(
       "children",
       children.flatMap(
         (child) => is_ast_node(child) && child.type === "JSXCodeBlock" ? lower_code_block_child(child) : [child]
@@ -26698,9 +25922,9 @@ function expand_child_code_blocks(node, seen = /* @__PURE__ */ new Set()) {
         if (walked !== entry) changed = true;
         return walked;
       });
-      if (changed) set(key2, result);
+      if (changed) set2(key2, result);
     } else if (is_ast_node(value)) {
-      set(key2, expand_child_code_blocks(value, seen));
+      set2(key2, expand_child_code_blocks(value, seen));
     }
   }
   return (
@@ -26782,26 +26006,26 @@ function wrap_control_flow_expression_values(node, transform_context, seen = /*
     node
   );
   let out = source;
-  const set = (key2, value) => {
+  const set2 = (key2, value) => {
     if (out[key2] === value) return;
     if (out === source) out = { ...source };
     out[key2] = value;
   };
   if (node.type === "ArrowFunctionExpression" && node.body?.type !== "BlockStatement" && is_template_directive(node.body)) {
-    set("body", wrap_in_native_tsrx_fragment(node.body));
+    set2("body", wrap_in_native_tsrx_fragment(node.body));
   } else if (node.type === "ReturnStatement" && is_template_directive(node.argument)) {
-    set("argument", wrap_in_native_tsrx_fragment(node.argument));
+    set2("argument", wrap_in_native_tsrx_fragment(node.argument));
   } else if (node.type === "ExpressionStatement" && is_template_directive(node.expression)) {
-    set("expression", wrap_in_native_tsrx_fragment(node.expression));
+    set2("expression", wrap_in_native_tsrx_fragment(node.expression));
   } else if (node.type === "VariableDeclarator" && is_template_directive(node.init)) {
-    set("init", wrap_in_native_tsrx_fragment(node.init));
+    set2("init", wrap_in_native_tsrx_fragment(node.init));
   } else if (node.type === "AssignmentExpression" && is_template_directive(node.right)) {
-    set("right", wrap_in_native_tsrx_fragment(node.right));
+    set2("right", wrap_in_native_tsrx_fragment(node.right));
   } else if ((node.type === "CallExpression" || node.type === "NewExpression") && Array.isArray(node.arguments)) {
     const args = node.arguments;
     const wrapped = args.map(wrap_value);
     if (wrapped.some((argument, i2) => argument !== args[i2])) {
-      set("arguments", wrapped);
+      set2("arguments", wrapped);
     }
   }
   for (const key2 of Object.keys(out)) {
@@ -26818,11 +26042,11 @@ function wrap_control_flow_expression_values(node, transform_context, seen = /*
         if (next !== entry) changed = true;
         return next;
       });
-      if (changed) set(key2, result);
+      if (changed) set2(key2, result);
     } else if (is_ast_node(value)) {
       let next = lower_child(value);
       if (!allowed_slot) next = wrap_directive_in_expression(next);
-      set(key2, wrap_control_flow_expression_values(next, transform_context, seen));
+      set2(key2, wrap_control_flow_expression_values(next, transform_context, seen));
     }
   }
   return (
@@ -26870,7 +26094,6 @@ function createJsxTransform(platform) {
       helper_state: null,
       hook_helpers_enabled: false,
       available_bindings: /* @__PURE__ */ new Map(),
-      lazy_next_id: 0,
       filename: filename ?? null,
       source,
       collect,
@@ -26894,9 +26117,6 @@ function createJsxTransform(platform) {
     expand_child_code_blocks(ast);
     ast = /** @type {AST.Program} */
     wrap_control_flow_expression_values(ast, transform_context);
-    if (!transform_context.typeOnly) {
-      preallocate_lazy_ids(ast, transform_context);
-    }
     const transformed = walk(
       /** @type {AST.Node} */
       ast,
@@ -27046,12 +26266,7 @@ function createJsxTransform(platform) {
     } else {
       inject_try_imports(expanded, transform_context, effective_platform, suspense_source);
     }
-    const lowered_program = lower_remaining_jsx_code_blocks(expanded, transform_context);
-    preallocate_lazy_ids(lowered_program, transform_context, transform_context.typeOnly);
-    const final_program = (
-      /** @type {AST.Program} */
-      apply_lazy_transforms(lowered_program, /* @__PURE__ */ new Map())
-    );
+    const final_program = lower_remaining_jsx_code_blocks(expanded, transform_context);
     const result = print(
       final_program,
       // typeOnly output is real TS input: re-emit preserved leading comments
@@ -27742,10 +26957,10 @@ function get_function_like_name(node) {
     return get_static_binding_name(parent.id);
   }
   if (parent.type === "Property" && parent.value === node) {
-    return get_static_property_name2(parent.key);
+    return get_static_property_name(parent.key);
   }
   if (parent.type === "MethodDefinition" && parent.value === node) {
-    return get_static_property_name2(parent.key);
+    return get_static_property_name(parent.key);
   }
   if (parent.type === "AssignmentExpression" && parent.right === node) {
     return get_static_binding_name(parent.left);
@@ -27757,11 +26972,11 @@ function get_static_binding_name(node) {
     return node.name;
   }
   if (node?.type === "MemberExpression" && !node.computed) {
-    return get_static_property_name2(node.property);
+    return get_static_property_name(node.property);
   }
   return null;
 }
-function get_static_property_name2(key2) {
+function get_static_property_name(key2) {
   if (key2?.type === "Identifier") {
     return key2.name;
   }
@@ -28077,9 +27292,6 @@ function collect_statement_bindings(statement, bindings) {
   if ((statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration") && statement.id) {
     bindings.set(statement.id.name, statement.id);
   }
-  if (statement.type === "ExpressionStatement" && statement.expression?.type === "AssignmentExpression" && statement.expression.operator === "=" && (statement.expression.left?.type === "ObjectPattern" || statement.expression.left?.type === "ArrayPattern") && statement.expression.left.lazy) {
-    collect_pattern_bindings(statement.expression.left, bindings);
-  }
 }
 function collect_pattern_bindings(pattern, bindings) {
   if (!pattern) return;
@@ -28196,7 +27408,7 @@ function lower_remaining_jsx_code_blocks(node, transform_context, seen = /* @__P
     is_function_node(node) ? lower_jsx_code_block_function_body(node) : node
   );
   let out = source;
-  const set = (key2, value) => {
+  const set2 = (key2, value) => {
     if (out[key2] === value) return;
     if (out === source) out = { ...source };
     out[key2] = value;
@@ -28224,9 +27436,9 @@ function lower_remaining_jsx_code_blocks(node, transform_context, seen = /* @__P
         if (walked !== child) changed = true;
         return walked;
       });
-      if (changed) set(key2, result);
+      if (changed) set2(key2, result);
     } else if (is_ast_node(value)) {
-      set(key2, lower_remaining_jsx_code_blocks(value, transform_context, seen));
+      set2(key2, lower_remaining_jsx_code_blocks(value, transform_context, seen));
     }
   }
   return (
@@ -30024,7 +29236,7 @@ function normalize_host_ref_spreads(attrs, is_host, transform_context) {
         const normalized_id = create_generated_identifier(
           create_spread_props_name(transform_context)
         );
-        const spread = {
+        const spread2 = {
           ...attr,
           argument: clone_identifier(normalized_id)
         };
@@ -30036,8 +29248,8 @@ function normalize_host_ref_spreads(attrs, is_host, transform_context) {
         );
         ref_attr.metadata = { ...ref_attr.metadata || {} };
         ref_attr.metadata.synthetic_ref = true;
-        add_jsx_setup_declaration(spread, let_builder(clone_identifier(normalized_id), normalized));
-        return [spread, ref_attr];
+        add_jsx_setup_declaration(spread2, let_builder(clone_identifier(normalized_id), normalized));
+        return [spread2, ref_attr];
       }
       return [
         {
@@ -30247,7 +29459,7 @@ function build_return_expression(render_nodes, in_jsx_child = false, type_only =
   );
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/source-map-utils.js
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/source-map-utils.js
 var mapping_data = {
   verification: true,
   completion: true,
@@ -30435,8 +29647,7 @@ function get_mapping_from_node(node, src_to_gen_map, gen_line_offsets, filtered_
   return mapping;
 }
 
-// ../../node_modules/.pnpm/@tsrx+core@0.1.71/node_modules/@tsrx/core/src/transform/segments.js
-var LAZY_PARAM_IDENTIFIER_REGEX = /^__lazy\d+$/;
+// ../../node_modules/.pnpm/@tsrx+core@0.2.0/node_modules/@tsrx/core/src/transform/segments.js
 var RETURN_KEYWORD = "return";
 var EXPORT_KEYWORD = "export";
 var BLOCK_DECLARATION_TYPES = /* @__PURE__ */ new Set([
@@ -30446,35 +29657,6 @@ var BLOCK_DECLARATION_TYPES = /* @__PURE__ */ new Set([
   "TSEnumDeclaration",
   "TSModuleDeclaration"
 ]);
-function escape_regex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function create_lazy_param_hover_replacement(lazy_id, base_hover) {
-  const lazy_param_regex = new RegExp(`\\b${escape_regex(lazy_id)}\\s*:\\s*`, "g");
-  return (content) => {
-    const next = base_hover ? base_hover(content) : content;
-    return next.replace(lazy_param_regex, "&");
-  };
-}
-function create_function_hover_replacement(params, base_hover) {
-  const lazy_ids = params?.filter(
-    (param) => param.type === "Identifier" && param.metadata?.source_length != null && LAZY_PARAM_IDENTIFIER_REGEX.test(param.name)
-  ).map((param) => (
-    /** @type {AST.Identifier} */
-    param.name
-  )) ?? [];
-  if (lazy_ids.length === 0) return base_hover;
-  const lazy_param_regexes = lazy_ids.map(
-    (lazy_id) => new RegExp(`\\b${escape_regex(lazy_id)}\\s*:\\s*`, "g")
-  );
-  return (content) => {
-    let next = base_hover ? base_hover(content) : content;
-    for (const regex of lazy_param_regexes) {
-      next = next.replace(regex, "&");
-    }
-    return next;
-  };
-}
 function get_style_region_id(hash, fallback) {
   return `style-${hash || fallback}`;
 }
@@ -30844,9 +30026,6 @@ function convert_source_map_to_mappings(ast, ast_from_source, source, generated_
               sourceLength: node.metadata?.source_length
             };
           }
-          if (node.metadata?.source_length != null && LAZY_PARAM_IDENTIFIER_REGEX.test(node.name)) {
-            token.metadata.hover = create_lazy_param_hover_replacement(node.name);
-          }
           if (node.metadata && "hover" in node.metadata) {
             token.metadata.hover = node.metadata.hover;
           }
@@ -30861,24 +30040,6 @@ function convert_source_map_to_mappings(ast, ast_from_source, source, generated_
           }
           tokens.push(token);
           add_extra_source_mapping_tokens(node);
-          if (Array.isArray(node.metadata?.lazy_param_binding_mappings)) {
-            for (const binding_mapping of node.metadata.lazy_param_binding_mappings) {
-              const source_node = binding_mapping.source;
-              const generated_node = binding_mapping.generated;
-              if (!has_location(source_node) || !has_location(generated_node)) continue;
-              const mapping = get_mapping_from_node(
-                generated_node,
-                src_to_gen_map,
-                gen_line_offsets,
-                mapping_data_verify_only
-              );
-              const source_start = source_node.start;
-              const source_end = source_node.end;
-              mapping.sourceOffsets = [source_start];
-              mapping.lengths = [source_end - source_start];
-              mappings.push(mapping);
-            }
-          }
         }
         return;
       } else if (node.type === "JSXIdentifier") {
@@ -31158,10 +30319,6 @@ function convert_source_map_to_mappings(ast, ast_from_source, source, generated_
             /** @type (typeof node) & AST.NodeWithLocation */
             node
           );
-          const function_hover = create_function_hover_replacement(
-            /** @type {AST.Parameter[]} */
-            node.params
-          );
           const keyword_bound = node_fn.id?.start ?? node_fn.params?.[0]?.start ?? node_fn.body?.start ?? node_fn.end;
           const lexer_tokens = ast_from_source.tsrx_keyword_tokens ?? [];
           const keyword_loc = (keyword, from) => {
@@ -31198,7 +30355,7 @@ function convert_source_map_to_mappings(ast, ast_from_source, source, generated_
               source: "function",
               generated: "function",
               loc: function_loc,
-              metadata: function_hover ? { hover: function_hover } : {}
+              metadata: {}
             });
           }
         }
@@ -31211,24 +30368,10 @@ function convert_source_map_to_mappings(ast, ast_from_source, source, generated_
             /** @type {AST.FunctionDeclaration | AST.FunctionExpression} */
             node.id
           );
-          const function_hover = create_function_hover_replacement(
-            /** @type {AST.Parameter[]} */
-            node.params
+          visit(
+            /** @type {AST.Node} */
+            id2
           );
-          if (function_hover && id2.loc) {
-            tokens.push({
-              source: id2.metadata?.source_name ?? id2.name,
-              generated: id2.name,
-              loc: id2.loc,
-              metadata: { hover: function_hover },
-              sourceLength: id2.metadata?.source_length
-            });
-          } else {
-            visit(
-              /** @type {AST.Node} */
-              id2
-            );
-          }
         }
         if (node.typeParameters) {
           visit(node.typeParameters);
@@ -31522,16 +30665,9 @@ function convert_source_map_to_mappings(ast, ast_from_source, source, generated_
           visit(node.right);
         }
         if (node.type === "AssignmentPattern") {
-          if (node.left.type !== "ObjectPattern" && node.left.type !== "ArrayPattern" || !node.left.lazy) {
-            mappings.push(
-              get_mapping_from_node(
-                node,
-                src_to_gen_map,
-                gen_line_offsets,
-                mapping_data_verify_only
-              )
-            );
-          }
+          mappings.push(
+            get_mapping_from_node(node, src_to_gen_map, gen_line_offsets, mapping_data_verify_only)
+          );
         }
         return;
       } else if (node.type === "ObjectExpression" || node.type === "ObjectPattern") {
@@ -32654,6 +31790,13 @@ import { analyzeNativeChangeDiagnostics } from "./native-change-diagnostics.js";
 import { analyzeStrongMode } from "./strong-mode.js";
 import { analyzeNativeReadDiagnostics, nativeReadOptions } from "./native-read-diagnostics.js";
 import { jsxImportSourcePragmaModule } from "./pragma.js";
+import { inheritHookMemoOrigin } from "./inline-hook-memo.js";
+import { lowerNativeAttributeReads } from "./native-attribute-reads.js";
+import {
+  collectServerFunctionNodes,
+  serverContextTypeImports,
+  serverFunctionContextIndex
+} from "./server-context.js";
 import {
   DOM_RENDERER_MODULE,
   normalizeRendererConfig,
@@ -32686,6 +31829,149 @@ var OCTANE_PLATFORM = {
   }
 };
 var octaneTransform = createJsxTransform(OCTANE_PLATFORM);
+function projectNativeAttributeReads(ast, contracts) {
+  const attributes = new Set(
+    contracts?.flatMap((contract) => contract.jsxAttribute ? [contract.jsxAttribute] : [])
+  );
+  if (attributes.size === 0) return ast;
+  const names = /* @__PURE__ */ new Set();
+  const walk2 = (node, replace) => {
+    if (!node || typeof node !== "object") return node;
+    if (Array.isArray(node)) return node.map((child) => walk2(child, replace));
+    let result = node;
+    for (const key2 of Object.keys(node)) {
+      if (["metadata", "loc", "start", "end", "parent"].includes(key2)) continue;
+      const value = node[key2];
+      if (!value || typeof value !== "object") continue;
+      const next = walk2(value, replace);
+      if (next !== value) {
+        if (result === node) result = { ...node };
+        result[key2] = next;
+      }
+    }
+    return replace(result) ?? result;
+  };
+  walk2(ast, (node) => {
+    if (node.type === "Identifier" || node.type === "JSXIdentifier") names.add(node.name);
+    return null;
+  });
+  let helper = "__octane_nativeAttributeValue";
+  while (names.has(helper)) helper += "_";
+  let used = false;
+  const projected = walk2(ast, (node) => {
+    if (node.type !== "JSXOpeningElement" && node.type !== "Element") return null;
+    const name = node.type === "Element" ? node.id : node.name;
+    if (name?.type !== "JSXIdentifier" && name?.type !== "Identifier" || typeof name.name !== "string" || name.name[0] !== name.name[0].toLowerCase())
+      return null;
+    return {
+      ...node,
+      attributes: node.attributes.map((attribute) => {
+        if (!attributes.has(attribute.name?.name ?? attribute.name) || attribute.value?.type !== "JSXExpressionContainer")
+          return attribute;
+        const result = lowerNativeAttributeReads(attribute.value.expression, (value) => {
+          used = true;
+          return inheritHookMemoOrigin(builders_exports.call(builders_exports.id(helper), value), value);
+        });
+        return { ...attribute, value: { ...attribute.value, expression: result.expression } };
+      })
+    };
+  });
+  return used ? {
+    ...projected,
+    body: [
+      builders_exports.imports([["readNativeDomValue", helper]], "octane/internal/signal-read"),
+      ...projected.body
+    ]
+  } : ast;
+}
+function projectServerContextCalls(ast, filename) {
+  const declaration2 = ast.body.find(
+    (node) => node.type === "TSModuleDeclaration" && node.kind === "module" && !node.declare && (node.id?.name ?? node.id?.value) === "server"
+  );
+  if (!Array.isArray(declaration2?.body?.body)) return ast;
+  const statements = declaration2.body.body;
+  const functions = collectServerFunctionNodes(statements);
+  const imports2 = serverContextTypeImports(statements);
+  const contextExports = /* @__PURE__ */ new Set();
+  const add = (exported, local) => {
+    const fn = functions.get(local);
+    if (fn === void 0) return;
+    try {
+      if (serverFunctionContextIndex(fn, imports2, filename) !== -1) contextExports.add(exported);
+    } catch {
+    }
+  };
+  for (const statement of statements) {
+    if (statement.type !== "ExportNamedDeclaration" || statement.exportKind === "type") continue;
+    const node = statement.declaration;
+    if (node?.type === "FunctionDeclaration") add(node.id?.name, node.id?.name);
+    if (node?.type === "VariableDeclaration") {
+      for (const item of node.declarations) add(item.id?.name, item.id?.name);
+    }
+    for (const specifier of statement.specifiers ?? []) {
+      if (specifier.exportKind !== "type") {
+        add(specifier.exported.name ?? specifier.exported.value, specifier.local.name);
+      }
+    }
+  }
+  if (contextExports.size === 0) return ast;
+  const names = /* @__PURE__ */ new Set();
+  const collectNames = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const child of node) collectNames(child);
+      return;
+    }
+    if (node.type === "Identifier") names.add(node.name);
+    for (const key2 in node) {
+      if (key2 !== "metadata" && key2 !== "loc" && key2 !== "parent") collectNames(node[key2]);
+    }
+  };
+  collectNames(ast);
+  let helper = "__octane_ServerFunction";
+  while (names.has(helper)) helper += "_";
+  let changed = false;
+  const body = [];
+  for (const statement of ast.body) {
+    if (statement.type !== "ImportDeclaration" || statement.source.value !== "server" || statement.importKind === "type") {
+      body.push(statement);
+      continue;
+    }
+    const retained = [];
+    for (const specifier of statement.specifiers) {
+      if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type" || !contextExports.has(specifier.imported.name ?? specifier.imported.value)) {
+        retained.push(specifier);
+        continue;
+      }
+      changed = true;
+      const reference = () => builders_exports.member(
+        builders_exports.id("server"),
+        { ...specifier.imported },
+        specifier.imported.type !== "Identifier"
+      );
+      body.push(
+        inheritHookMemoOrigin(
+          builders_exports.const(
+            { ...specifier.local },
+            builders_exports.ts_as(
+              builders_exports.ts_as(reference(), builders_exports.ts_keyword_type("unknown")),
+              builders_exports.ts_type_reference(
+                builders_exports.id(helper),
+                builders_exports.ts_type_parameter_instantiation([builders_exports.ts_type_query(reference())])
+              )
+            )
+          ),
+          specifier
+        )
+      );
+    }
+    if (retained.length > 0) body.push({ ...statement, specifiers: retained });
+  }
+  return changed ? {
+    ...ast,
+    body: [builders_exports.imports([["ServerFunction", helper]], "octane/server", [], "type"), ...body]
+  } : ast;
+}
 var octaneTransformWithAuthoredSuspense = createJsxTransform({
   ...OCTANE_PLATFORM,
   hooks: {
@@ -32703,13 +31989,13 @@ function selectOctaneTransform(ast) {
   );
   return hasSuspenseImport ? octaneTransformWithAuthoredSuspense : octaneTransform;
 }
-function hasAuthoredLeadingPragma(ast, comments) {
+function authoredLeadingPragma(ast, comments) {
   const firstStatementStart = ast.body?.[0]?.start;
-  return comments.some(
+  return comments.find(
     (comment) => (firstStatementStart == null || comment.end <= firstStatementStart) && jsxImportSourcePragmaModule(comment.value) !== null
   );
 }
-function createRendererTypePragma(renderer, ast) {
+function createRendererTypePragma(renderer, ast, strong = false) {
   const intrinsics = renderer.intrinsics ?? (renderer.module === DOM_RENDERER_MODULE && renderer.target === "dom" ? DOM_RENDERER_MODULE : void 0);
   if (intrinsics === void 0) return null;
   const start = ast.loc?.start ?? { line: 1, column: 0 };
@@ -32717,7 +32003,7 @@ function createRendererTypePragma(renderer, ast) {
     type: "Block",
     // @tsrx/core's semantic-comment formatter turns this into the canonical
     // `/** @jsxImportSource … */` spelling during the one type-only print.
-    value: `*@jsxImportSource ${intrinsics}`,
+    value: `*@jsxImportSource ${strong && intrinsics === DOM_RENDERER_MODULE ? "octane/strong" : intrinsics}`,
     start: ast.start ?? 0,
     end: ast.start ?? 0,
     loc: { start: { ...start }, end: { ...start } },
@@ -32766,14 +32052,21 @@ function compileToVolarMappings(source, filename, options) {
   });
   const rendererConfig = normalizeRendererConfig(options?.renderers);
   const renderer = resolveRendererForFile(rendererConfig, filename ?? "untitled.tsrx");
-  const diagnostics = analyzeNativeChangeDiagnostics(ast, source, filename, {
+  const strongAnalysis = options?.strong === true || source.includes("use strong") ? analyzeStrongMode(ast, source, filename, {
+    ...options,
+    renderer,
+    rendererBoundaries: rendererConfig.boundaries,
+    rendererRegistry: rendererConfig.registry
+  }) : null;
+  const strongDiagnostics = strongAnalysis?.diagnostics ?? null;
+  const diagnostics = strongAnalysis?.enabled ? [...strongDiagnostics] : analyzeNativeChangeDiagnostics(ast, source, filename, {
     dom: renderer.target === "dom",
     renderer,
     rendererBoundaries: rendererConfig.boundaries,
     rendererRegistry: rendererConfig.registry
   }).diagnostics;
-  const strongDiagnostics = options?.strong === true || source.includes("use strong") ? analyzeStrongMode(ast, source, filename, options).diagnostics : null;
-  if (strongDiagnostics !== null) diagnostics.push(...strongDiagnostics);
+  if (!strongAnalysis?.enabled && strongDiagnostics !== null)
+    diagnostics.push(...strongDiagnostics);
   const nativeReadDiagnostics = analyzeNativeReadDiagnostics(
     ast,
     source,
@@ -32786,21 +32079,45 @@ function compileToVolarMappings(source, filename, options) {
     })
   );
   diagnostics.push(...nativeReadDiagnostics);
-  const rendererPragma = hasAuthoredLeadingPragma(ast, comments) ? null : createRendererTypePragma(renderer, ast);
-  const printComments = rendererPragma === null ? comments : [rendererPragma, ...comments];
+  const authoredPragma = authoredLeadingPragma(ast, comments);
+  const strongDOM = strongAnalysis?.enabled === true && renderer.target === "dom";
+  const rendererPragma = authoredPragma ? null : createRendererTypePragma(renderer, ast, strongDOM);
+  const replacePragma = authoredPragma && strongDOM && jsxImportSourcePragmaModule(authoredPragma.value) === DOM_RENDERER_MODULE;
+  const strongPragma = replacePragma ? {
+    ...authoredPragma,
+    value: authoredPragma.type === "Line" ? " @jsxImportSource octane/strong" : "*@jsxImportSource octane/strong"
+  } : null;
+  const printComments = strongPragma ? comments.map((comment) => comment === authoredPragma ? strongPragma : comment) : rendererPragma === null ? comments : [rendererPragma, ...comments];
+  let transformAst = ast;
+  if (strongPragma && ast.body.length > 0) {
+    const first = clone_ast_node(ast.body[0]);
+    first.leadingComments = first.leadingComments?.map(
+      (comment) => comment.start === authoredPragma.start && comment.end === authoredPragma.end ? strongPragma : comment
+    );
+    transformAst = { ...ast, body: [first, ...ast.body.slice(1)] };
+  }
   const transform = selectOctaneTransform(ast);
-  const transformed = transform(ast, source, filename, {
-    collect: true,
-    loose: !!options?.loose,
-    // @tsrx/core routes `typeOnly: true` to its TSX esrap language with
-    // `boundaryTokens: true`. Structural delimiters then carry their own
-    // one-character mappings without changing the virtual TSX bytes.
-    typeOnly: true,
-    errors,
-    comments: printComments
-  });
+  const transformed = transform(
+    projectServerContextCalls(
+      renderer.target === "dom" ? projectNativeAttributeReads(transformAst, options?.knownAttributeSpreads) : transformAst,
+      filename
+    ),
+    source,
+    filename,
+    {
+      collect: true,
+      loose: !!options?.loose,
+      // @tsrx/core routes `typeOnly: true` to its TSX esrap language with
+      // `boundaryTokens: true`. Structural delimiters then carry their own
+      // one-character mappings without changing the virtual TSX bytes.
+      typeOnly: true,
+      errors,
+      comments: printComments
+    }
+  );
   if (strongDiagnostics !== null || nativeReadDiagnostics.length > 0) {
     for (const diagnostic of [...strongDiagnostics ?? [], ...nativeReadDiagnostics]) {
+      if (diagnostic.severity !== "error") continue;
       error(
         diagnostic.message,
         diagnostic.filename ?? null,
@@ -32932,9 +32249,9 @@ function compileTypesInspection(source, filename, options) {
   analyze_tsrx(ast, filename, { collect: true, loose: true, to_ts: true, errors, comments });
   const rendererConfig = normalizeRendererConfig(options?.renderers);
   const renderer = resolveRendererForFile(rendererConfig, filename ?? "untitled.tsrx");
-  const rendererPragma = hasAuthoredLeadingPragma(ast, comments) ? null : createRendererTypePragma(renderer, ast);
+  const rendererPragma = authoredLeadingPragma(ast, comments) ? null : createRendererTypePragma(renderer, ast);
   const transform = selectOctaneTransform(ast);
-  const transformed = transform(ast, source, filename, {
+  const transformed = transform(projectServerContextCalls(ast, filename), source, filename, {
     collect: true,
     loose: true,
     typeOnly: true,