octane 0.2.12 → 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,6 +11449,116 @@ function apply_mutations(node, mutations) {
   );
 }
 
+// ../../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;
@@ -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,29 @@ 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} */
+    {
+      type: "ParenthesizedExpression",
+      expression,
+      metadata: { path: [] }
+    }
+  );
+  return set_location(node, loc_info);
+}
 function ts_type_query(expr_name, type_arguments = null, loc_info) {
   const node = (
     /** @type {AST.TSTypeQuery} */
@@ -11633,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",
@@ -11736,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);
@@ -11767,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: [] } };
 }
@@ -11778,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,
@@ -11795,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);
@@ -11804,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",
@@ -11837,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",
@@ -11974,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} */
@@ -12004,6 +12367,16 @@ 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.2.0/node_modules/@tsrx/core/src/utils/ast.js
 function is_ast_node(value) {
@@ -15127,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 {
@@ -21278,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 = [];
@@ -21392,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,
@@ -21528,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);
     },
@@ -21587,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(" ");
@@ -21629,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,
@@ -21719,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,
@@ -21743,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,
@@ -21779,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(" => ");
@@ -21941,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 ");
@@ -22058,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 ");
@@ -22129,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);
     },
@@ -22171,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,
@@ -22210,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"],
@@ -22382,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);
@@ -22438,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) {
@@ -22571,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);
     },
@@ -22621,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,
@@ -22636,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) {
@@ -22646,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 ");
@@ -22727,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("}");
@@ -22768,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 ");
@@ -22777,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);
@@ -23846,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;
@@ -24405,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;
@@ -24414,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;
@@ -24424,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;
@@ -25371,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(
@@ -25397,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];
@@ -25524,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]
@@ -25549,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 (
@@ -25633,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)) {
@@ -25669,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 (
@@ -27035,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;
@@ -27063,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 (
@@ -28863,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)
         };
@@ -28875,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 [
         {
@@ -31417,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,
@@ -31449,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: {
@@ -31574,16 +32097,24 @@ function compileToVolarMappings(source, filename, options) {
     transformAst = { ...ast, body: [first, ...ast.body.slice(1)] };
   }
   const transform = selectOctaneTransform(ast);
-  const transformed = transform(transformAst, 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;
@@ -31720,7 +32251,7 @@ function compileTypesInspection(source, filename, options) {
   const renderer = resolveRendererForFile(rendererConfig, filename ?? "untitled.tsrx");
   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,