babel-plugin-react-compiler 0.0.0-experimental-b719367-20241104 → 0.0.0-experimental-fcabbc1-20241106

package/dist/index.js

@@ -136633,8 +136633,8 @@ const ExternalFunctionSchema = z.object({
 const InstrumentationSchema = z
   .object({
     fn: ExternalFunctionSchema,
-    gating: ExternalFunctionSchema.nullish(),
-    globalGating: z.string().nullish(),
+    gating: ExternalFunctionSchema.nullable(),
+    globalGating: z.string().nullable(),
   })
   .refine(
     opts => opts.gating != null || opts.globalGating != null,
@@ -136655,7 +136655,7 @@ const HookSchema = z.object({
   transitiveMixedData: z.boolean().default(false),
 });
 const EnvironmentConfigSchema = z.object({
-  customHooks: z.map(z.string(), HookSchema).optional().default(new Map()),
+  customHooks: z.map(z.string(), HookSchema).default(new Map()),
   moduleTypeProvider: z.nullable(z.function().args(z.string())).default(null),
   customMacros: z.nullable(z.array(MacroSchema)).default(null),
   enableResetCacheOnSourceFileChanges: z.boolean().default(false),
@@ -136664,9 +136664,7 @@ const EnvironmentConfigSchema = z.object({
   enablePreserveExistingManualUseMemo: z.boolean().default(false),
   enableForest: z.boolean().default(false),
   enableUseTypeAnnotations: z.boolean().default(false),
-  enablePropagateDepsInHIR: z.boolean().default(false),
-  enableOptionalDependencies: z.boolean().default(true),
-  inlineJsxTransform: ReactElementSymbolSchema.nullish(),
+  inlineJsxTransform: ReactElementSymbolSchema.nullable().default(null),
   validateHooksUsage: z.boolean().default(true),
   validateRefAccessDuringRender: z.boolean().default(true),
   validateNoSetStateInRender: z.boolean().default(true),
@@ -136677,26 +136675,60 @@ const EnvironmentConfigSchema = z.object({
   validateBlocklistedImports: z.nullable(z.array(z.string())).default(null),
   enableAssumeHooksFollowRulesOfReact: z.boolean().default(true),
   enableTransitivelyFreezeFunctionExpressions: z.boolean().default(true),
-  enableEmitFreeze: ExternalFunctionSchema.nullish(),
-  enableEmitHookGuards: ExternalFunctionSchema.nullish(),
+  enableEmitFreeze: ExternalFunctionSchema.nullable().default(null),
+  enableEmitHookGuards: ExternalFunctionSchema.nullable().default(null),
   enableInstructionReordering: z.boolean().default(false),
   enableFunctionOutlining: z.boolean().default(true),
   enableJsxOutlining: z.boolean().default(false),
-  enableEmitInstrumentForget: InstrumentationSchema.nullish(),
+  enableEmitInstrumentForget: InstrumentationSchema.nullable().default(null),
   assertValidMutableRanges: z.boolean().default(false),
   enableChangeVariableCodegen: z.boolean().default(false),
   enableMemoizationComments: z.boolean().default(false),
   throwUnknownException__testonly: z.boolean().default(false),
-  enableSharedRuntime__testonly: z.boolean().default(false),
   enableTreatFunctionDepsAsConditional: z.boolean().default(false),
   disableMemoizationForDebugging: z.boolean().default(false),
-  enableChangeDetectionForDebugging: ExternalFunctionSchema.nullish(),
+  enableChangeDetectionForDebugging:
+    ExternalFunctionSchema.nullable().default(null),
   enableCustomTypeDefinitionForReanimated: z.boolean().default(false),
   hookPattern: z.string().nullable().default(null),
-  enableTreatRefLikeIdentifiersAsRefs: z.boolean().nullable().default(false),
-  lowerContextAccess: ExternalFunctionSchema.nullish(),
+  enableTreatRefLikeIdentifiersAsRefs: z.boolean().default(false),
+  lowerContextAccess: ExternalFunctionSchema.nullable().default(null),
 });
-function parseConfigPragma(pragma) {
+const testComplexConfigDefaults = {
+  validateNoCapitalizedCalls: [],
+  enableChangeDetectionForDebugging: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: '$structuralCheck',
+  },
+  enableEmitFreeze: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: 'makeReadOnly',
+  },
+  enableEmitInstrumentForget: {
+    fn: {
+      source: 'react-compiler-runtime',
+      importSpecifierName: 'useRenderCounter',
+    },
+    gating: {
+      source: 'react-compiler-runtime',
+      importSpecifierName: 'shouldInstrument',
+    },
+    globalGating: '__DEV__',
+  },
+  enableEmitHookGuards: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: '$dispatcherGuard',
+  },
+  inlineJsxTransform: {
+    elementSymbol: 'react.transitional.element',
+    globalDevVar: 'DEV',
+  },
+  lowerContextAccess: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: 'useContext_withSelector',
+  },
+};
+function parseConfigPragmaForTests(pragma) {
   const maybeConfig = {};
   const defaultConfig = EnvironmentConfigSchema.parse({});
   for (const token of pragma.split(' ')) {
@@ -136704,19 +136736,10 @@ function parseConfigPragma(pragma) {
       continue;
     }
     const keyVal = token.slice(1);
-    let [key, val] = keyVal.split(':');
-    if (key === 'validateNoCapitalizedCalls') {
-      maybeConfig[key] = [];
-      continue;
-    }
-    if (
-      key === 'enableChangeDetectionForDebugging' &&
-      (val === undefined || val === 'true')
-    ) {
-      maybeConfig[key] = {
-        source: 'react-compiler-runtime',
-        importSpecifierName: '$structuralCheck',
-      };
+    let [key, val = undefined] = keyVal.split(':');
+    const isSet = val === undefined || val === 'true';
+    if (isSet && key in testComplexConfigDefaults) {
+      maybeConfig[key] = testComplexConfigDefaults[key];
       continue;
     }
     if (key === 'customMacros' && val) {
@@ -136730,15 +136753,6 @@ function parseConfigPragma(pragma) {
             props.push({type: 'name', name: elt});
           }
         }
-        console.log([
-          valSplit[0],
-          props
-            .map(x => {
-              var _a;
-              return (_a = x.name) !== null && _a !== void 0 ? _a : '*';
-            })
-            .join('.'),
-        ]);
         maybeConfig[key] = [[valSplit[0], props]];
       }
       continue;
@@ -136747,11 +136761,10 @@ function parseConfigPragma(pragma) {
       continue;
     }
     if (val === undefined || val === 'true') {
-      val = true;
+      maybeConfig[key] = true;
     } else {
-      val = false;
+      maybeConfig[key] = false;
     }
-    maybeConfig[key] = val;
   }
   const config = EnvironmentConfigSchema.safeParse(maybeConfig);
   if (config.success) {
@@ -139841,7 +139854,7 @@ function findContextIdentifiers(func) {
         const currentFn =
           (_a = state.currentFn.at(-1)) !== null && _a !== void 0 ? _a : null;
         if (path.isReferencedIdentifier()) {
-          handleIdentifier(currentFn, state.identifiers, path);
+          handleIdentifier$1(currentFn, state.identifiers, path);
         }
       },
     },
@@ -139857,7 +139870,7 @@ function findContextIdentifiers(func) {
   }
   return result;
 }
-function handleIdentifier(currentFn, identifiers, path) {
+function handleIdentifier$1(currentFn, identifiers, path) {
   const name = path.node.name;
   const binding = path.scope.getBinding(name);
   if (binding == null) {
@@ -141467,6 +141480,28 @@ function inlineJsxTransform(fn, inlineJsxTransformConfig) {
     mapTerminalOperands(block.terminal, place =>
       handlePlace(place, blockId, inlinedJsxDeclarations)
     );
+    if (block.terminal.kind === 'scope') {
+      const scope = block.terminal.scope;
+      for (const dep of scope.dependencies) {
+        dep.identifier = handleIdentifier(
+          dep.identifier,
+          inlinedJsxDeclarations
+        );
+      }
+      for (const [origId, decl] of [...scope.declarations]) {
+        const newDecl = handleIdentifier(
+          decl.identifier,
+          inlinedJsxDeclarations
+        );
+        if (newDecl.id !== origId) {
+          scope.declarations.delete(origId);
+          scope.declarations.set(decl.identifier.id, {
+            identifier: newDecl,
+            scope: decl.scope,
+          });
+        }
+      }
+    }
   }
   reversePostorderBlocks(fn.body);
   markPredecessors(fn.body);
@@ -141773,10 +141808,10 @@ function handlePlace(place, blockId, inlinedJsxDeclarations) {
     inlinedJsxDeclaration == null ||
     inlinedJsxDeclaration.blockIdsToIgnore.has(blockId)
   ) {
-    return Object.assign({}, place);
+    return place;
   }
   return Object.assign(Object.assign({}, place), {
-    identifier: Object.assign({}, inlinedJsxDeclaration.identifier),
+    identifier: inlinedJsxDeclaration.identifier,
   });
 }
 function handlelValue(lvalue, blockId, inlinedJsxDeclarations) {
@@ -141787,12 +141822,20 @@ function handlelValue(lvalue, blockId, inlinedJsxDeclarations) {
     inlinedJsxDeclaration == null ||
     inlinedJsxDeclaration.blockIdsToIgnore.has(blockId)
   ) {
-    return Object.assign({}, lvalue);
+    return lvalue;
   }
   return Object.assign(Object.assign({}, lvalue), {
-    identifier: Object.assign({}, inlinedJsxDeclaration.identifier),
+    identifier: inlinedJsxDeclaration.identifier,
   });
 }
+function handleIdentifier(identifier, inlinedJsxDeclarations) {
+  const inlinedJsxDeclaration = inlinedJsxDeclarations.get(
+    identifier.declarationId
+  );
+  return inlinedJsxDeclaration == null
+    ? identifier
+    : inlinedJsxDeclaration.identifier;
+}
 function findScopesToMerge(fn) {
   const objectMethodDecls = new Set();
   const mergeScopesBuilder = new DisjointSet();
@@ -142451,7 +142494,7 @@ var _Context_nextScheduleId,
   _Context_catchHandlers,
   _Context_controlFlowStack;
 function buildReactiveFunction(fn) {
-  const cx = new Context$3(fn.body);
+  const cx = new Context$2(fn.body);
   const driver = new Driver(cx);
   const body = driver.traverseBlock(cx.block(fn.body.entry));
   return {
@@ -143499,7 +143542,7 @@ class Driver {
     };
   }
 }
-let Context$3 = class Context {
+let Context$2 = class Context {
   constructor(ir) {
     _Context_nextScheduleId.set(this, 0);
     this.emitted = new Set();
@@ -143879,7 +143922,7 @@ function expandFbtScopeRange(fbtRange, extendWith) {
     );
   }
 }
-var _Context_nextCacheIndex, _Context_declarations$2;
+var _Context_nextCacheIndex, _Context_declarations$1;
 const MEMO_CACHE_SENTINEL = 'react.memo_cache_sentinel';
 const EARLY_RETURN_SENTINEL = 'react.early_return_sentinel';
 function codegenFunction(
@@ -143887,7 +143930,7 @@ function codegenFunction(
   {uniqueIdentifiers: uniqueIdentifiers, fbtOperands: fbtOperands}
 ) {
   var _a, _b, _c;
-  const cx = new Context$2(
+  const cx = new Context$1(
     fn.env,
     (_a = fn.id) !== null && _a !== void 0 ? _a : '[[ anonymous ]]',
     uniqueIdentifiers,
@@ -144052,7 +144095,7 @@ function codegenFunction(
     pruneHoistedContexts(reactiveFunction);
     const identifiers = renameVariables(reactiveFunction);
     const codegen = codegenReactiveFunction(
-      new Context$2(
+      new Context$1(
         cx.env,
         (_c = reactiveFunction.id) !== null && _c !== void 0
           ? _c
@@ -144139,10 +144182,10 @@ function convertParameter(param) {
     return t__namespace.restElement(convertIdentifier(param.place.identifier));
   }
 }
-let Context$2 = class Context {
+let Context$1 = class Context {
   constructor(env, fnName, uniqueIdentifiers, fbtOperands, temporaries = null) {
     _Context_nextCacheIndex.set(this, 0);
-    _Context_declarations$2.set(this, new Set());
+    _Context_declarations$1.set(this, new Set());
     this.errors = new CompilerError();
     this.objectMethods = new Map();
     this.synthesizedNames = new Map();
@@ -144167,12 +144210,12 @@ let Context$2 = class Context {
     );
   }
   declare(identifier) {
-    __classPrivateFieldGet(this, _Context_declarations$2, 'f').add(
+    __classPrivateFieldGet(this, _Context_declarations$1, 'f').add(
       identifier.declarationId
     );
   }
   hasDeclared(identifier) {
-    return __classPrivateFieldGet(this, _Context_declarations$2, 'f').has(
+    return __classPrivateFieldGet(this, _Context_declarations$1, 'f').has(
       identifier.declarationId
     );
   }
@@ -144192,7 +144235,7 @@ let Context$2 = class Context {
   }
 };
 (_Context_nextCacheIndex = new WeakMap()),
-  (_Context_declarations$2 = new WeakMap());
+  (_Context_declarations$1 = new WeakMap());
 function codegenBlock(cx, block) {
   const temp = new Map(cx.temp);
   const result = codegenBlockNoReset(cx, block);
@@ -144285,7 +144328,7 @@ function codegenReactiveScope(cx, statements, scope, block) {
   const changeExpressions = [];
   const changeExpressionComments = [];
   const outputComments = [];
-  for (const dep of scope.dependencies) {
+  for (const dep of [...scope.dependencies].sort(compareScopeDependency)) {
     const index = cx.nextCacheIndex;
     changeExpressionComments.push(printDependencyComment(dep));
     const comparison = t__namespace.binaryExpression(
@@ -144325,7 +144368,9 @@ function codegenReactiveScope(cx, statements, scope, block) {
     );
   }
   let firstOutputIndex = null;
-  for (const [, {identifier: identifier}] of scope.declarations) {
+  for (const [, {identifier: identifier}] of [...scope.declarations].sort(
+    ([, a], [, b]) => compareScopeDeclaration(a, b)
+  )) {
     const index = cx.nextCacheIndex;
     if (firstOutputIndex === null) {
       firstOutputIndex = index;
@@ -145468,7 +145513,7 @@ function codegenInstructionValue(cx, instrValue) {
               pruneUnusedLabels(reactiveFunction);
               pruneUnusedLValues(reactiveFunction);
               const fn = codegenReactiveFunction(
-                new Context$2(
+                new Context$1(
                   cx.env,
                   (_e = reactiveFunction.id) !== null && _e !== void 0
                     ? _e
@@ -145667,7 +145712,7 @@ function codegenInstructionValue(cx, instrValue) {
       pruneUnusedLValues(reactiveFunction);
       pruneHoistedContexts(reactiveFunction);
       const fn = codegenReactiveFunction(
-        new Context$2(
+        new Context$1(
           cx.env,
           (_g = reactiveFunction.id) !== null && _g !== void 0
             ? _g
@@ -146136,6 +146181,50 @@ function convertIdentifier(identifier) {
   );
   return t__namespace.identifier(identifier.name.value);
 }
+function compareScopeDependency(a, b) {
+  var _a, _b;
+  CompilerError.invariant(
+    ((_a = a.identifier.name) === null || _a === void 0 ? void 0 : _a.kind) ===
+      'named' &&
+      ((_b = b.identifier.name) === null || _b === void 0
+        ? void 0
+        : _b.kind) === 'named',
+    {
+      reason: '[Codegen] Expected named identifier for dependency',
+      loc: a.identifier.loc,
+    }
+  );
+  const aName = [
+    a.identifier.name.value,
+    ...a.path.map(entry => `${entry.optional ? '?' : ''}${entry.property}`),
+  ].join('.');
+  const bName = [
+    b.identifier.name.value,
+    ...b.path.map(entry => `${entry.optional ? '?' : ''}${entry.property}`),
+  ].join('.');
+  if (aName < bName) return -1;
+  else if (aName > bName) return 1;
+  else return 0;
+}
+function compareScopeDeclaration(a, b) {
+  var _a, _b;
+  CompilerError.invariant(
+    ((_a = a.identifier.name) === null || _a === void 0 ? void 0 : _a.kind) ===
+      'named' &&
+      ((_b = b.identifier.name) === null || _b === void 0
+        ? void 0
+        : _b.kind) === 'named',
+    {
+      reason: '[Codegen] Expected named identifier for declaration',
+      loc: a.identifier.loc,
+    }
+  );
+  const aName = a.identifier.name.value;
+  const bName = b.identifier.name.value;
+  if (aName < bName) return -1;
+  else if (aName > bName) return 1;
+  else return 0;
+}
 function extractScopeDeclarationsFromDestructuring(fn) {
   const state = new State$1(fn.env);
   visitReactiveFunction(fn, new Visitor$9(), state);
@@ -147132,1677 +147221,68 @@ let Transform$3 = class Transform extends ReactiveFunctionTransform {
     return {kind: 'keep'};
   }
 };
-var _Node_value, _Node_next;
-function empty() {
-  return EMPTY;
-}
-class Node {
-  constructor(value, next = EMPTY) {
-    _Node_value.set(this, void 0);
-    _Node_next.set(this, void 0);
-    __classPrivateFieldSet(this, _Node_value, value, 'f');
-    __classPrivateFieldSet(this, _Node_next, next, 'f');
-  }
-  push(value) {
-    return new Node(value, this);
-  }
-  pop() {
-    return __classPrivateFieldGet(this, _Node_next, 'f');
-  }
-  find(fn) {
-    return fn(__classPrivateFieldGet(this, _Node_value, 'f'))
-      ? true
-      : __classPrivateFieldGet(this, _Node_next, 'f').find(fn);
-  }
-  contains(value) {
-    return (
-      value === __classPrivateFieldGet(this, _Node_value, 'f') ||
-      (__classPrivateFieldGet(this, _Node_next, 'f') !== null &&
-        __classPrivateFieldGet(this, _Node_next, 'f').contains(value))
-    );
-  }
-  each(fn) {
-    fn(__classPrivateFieldGet(this, _Node_value, 'f'));
-    __classPrivateFieldGet(this, _Node_next, 'f').each(fn);
-  }
-  get value() {
-    return __classPrivateFieldGet(this, _Node_value, 'f');
-  }
-  print(fn) {
-    return (
-      fn(__classPrivateFieldGet(this, _Node_value, 'f')) +
-      __classPrivateFieldGet(this, _Node_next, 'f').print(fn)
-    );
-  }
-}
-(_Node_value = new WeakMap()), (_Node_next = new WeakMap());
-class Empty {
-  push(value) {
-    return new Node(value, this);
-  }
-  pop() {
-    return this;
-  }
-  find(_fn) {
-    return false;
-  }
-  contains(_value) {
-    return false;
-  }
-  each(_fn) {
-    return;
-  }
-  get value() {
-    return null;
-  }
-  print(_) {
-    return '';
-  }
+function pruneHoistedContexts(fn) {
+  const hoistedIdentifiers = new Map();
+  visitReactiveFunction(fn, new Visitor$8(), hoistedIdentifiers);
 }
-const EMPTY = new Empty();
-var _ReactiveScopeDependencyTree_instances,
-  _ReactiveScopeDependencyTree_roots,
-  _ReactiveScopeDependencyTree_getOrCreateRoot,
-  _ReactiveScopeDependencyTree_debugImpl;
-class ReactiveScopeDependencyTree {
-  constructor() {
-    _ReactiveScopeDependencyTree_instances.add(this);
-    _ReactiveScopeDependencyTree_roots.set(this, new Map());
-  }
-  add(dep, inConditional) {
-    const {path: path} = dep;
-    let currNode = __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_instances,
-      'm',
-      _ReactiveScopeDependencyTree_getOrCreateRoot
-    ).call(this, dep.identifier);
-    for (const item of path) {
-      let currChild = getOrMakeProperty(currNode, item.property);
-      const accessType = inConditional
-        ? PropertyAccessType$1.ConditionalAccess
-        : item.optional
-          ? PropertyAccessType$1.OptionalAccess
-          : PropertyAccessType$1.UnconditionalAccess;
-      currChild.accessType = merge$1(currChild.accessType, accessType);
-      currNode = currChild;
-    }
-    const depType = inConditional
-      ? PropertyAccessType$1.ConditionalDependency
-      : isOptional$1(currNode.accessType)
-        ? PropertyAccessType$1.OptionalDependency
-        : PropertyAccessType$1.UnconditionalDependency;
-    currNode.accessType = merge$1(currNode.accessType, depType);
-  }
-  deriveMinimalDependencies() {
-    const results = new Set();
-    for (const [rootId, rootNode] of __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    ).entries()) {
-      const deps = deriveMinimalDependenciesInSubtree(rootNode, null);
-      CompilerError.invariant(
-        deps.every(
-          dep =>
-            dep.accessType === PropertyAccessType$1.UnconditionalDependency ||
-            dep.accessType == PropertyAccessType$1.OptionalDependency
-        ),
-        {
-          reason:
-            '[PropagateScopeDependencies] All dependencies must be reduced to unconditional dependencies.',
-          description: null,
-          loc: null,
-          suggestions: null,
-        }
+let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
+  transformInstruction(instruction, state) {
+    this.visitInstruction(instruction, state);
+    if (
+      instruction.value.kind === 'DeclareContext' &&
+      instruction.value.lvalue.kind === 'HoistedConst'
+    ) {
+      state.set(
+        instruction.value.lvalue.place.identifier.declarationId,
+        InstructionKind.Const
       );
-      for (const dep of deps) {
-        results.add({identifier: rootId, path: dep.relativePath});
-      }
-    }
-    return results;
-  }
-  addDepsFromInnerScope(
-    depsFromInnerScope,
-    innerScopeInConditionalWithinParent,
-    checkValidDepIdFn
-  ) {
-    for (const [id, otherRoot] of __classPrivateFieldGet(
-      depsFromInnerScope,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    )) {
-      if (!checkValidDepIdFn({identifier: id, path: []})) {
-        continue;
-      }
-      let currRoot = __classPrivateFieldGet(
-        this,
-        _ReactiveScopeDependencyTree_instances,
-        'm',
-        _ReactiveScopeDependencyTree_getOrCreateRoot
-      ).call(this, id);
-      addSubtree(currRoot, otherRoot, innerScopeInConditionalWithinParent);
-      if (!isUnconditional(currRoot.accessType)) {
-        currRoot.accessType = isDependency$1(currRoot.accessType)
-          ? PropertyAccessType$1.UnconditionalDependency
-          : PropertyAccessType$1.UnconditionalAccess;
-      }
+      return {kind: 'remove'};
     }
-  }
-  promoteDepsFromExhaustiveConditionals(trees) {
-    CompilerError.invariant(trees.length > 1, {
-      reason: 'Expected trees to be at least 2 elements long.',
-      description: null,
-      loc: null,
-      suggestions: null,
-    });
-    for (const [id, root] of __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    )) {
-      const nodesForRootId = mapNonNull(trees, tree => {
-        const node = __classPrivateFieldGet(
-          tree,
-          _ReactiveScopeDependencyTree_roots,
-          'f'
-        ).get(id);
-        if (node != null && isUnconditional(node.accessType)) {
-          return node;
-        } else {
-          return null;
-        }
-      });
-      if (nodesForRootId) {
-        addSubtreeIntersection(
-          root.properties,
-          nodesForRootId.map(root => root.properties)
-        );
-      }
+    if (
+      instruction.value.kind === 'DeclareContext' &&
+      instruction.value.lvalue.kind === 'HoistedLet'
+    ) {
+      state.set(
+        instruction.value.lvalue.place.identifier.declarationId,
+        InstructionKind.Let
+      );
+      return {kind: 'remove'};
     }
-  }
-  printDeps(includeAccesses) {
-    let res = [];
-    for (const [rootId, rootNode] of __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    ).entries()) {
-      const rootResults = printSubtree$1(rootNode, includeAccesses).map(
-        result => `${printIdentifier(rootId)}.${result}`
+    if (
+      instruction.value.kind === 'DeclareContext' &&
+      instruction.value.lvalue.kind === 'HoistedFunction'
+    ) {
+      state.set(
+        instruction.value.lvalue.place.identifier.declarationId,
+        InstructionKind.Function
       );
-      res.push(rootResults);
+      return {kind: 'remove'};
     }
-    return res.flat().join('\n');
-  }
-  debug() {
-    const buf = [`tree() [`];
-    for (const [rootId, rootNode] of __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    )) {
-      buf.push(`${printIdentifier(rootId)} (${rootNode.accessType}):`);
-      __classPrivateFieldGet(
-        this,
-        _ReactiveScopeDependencyTree_instances,
-        'm',
-        _ReactiveScopeDependencyTree_debugImpl
-      ).call(this, buf, rootNode, 1);
+    if (
+      instruction.value.kind === 'StoreContext' &&
+      state.has(instruction.value.lvalue.place.identifier.declarationId)
+    ) {
+      const kind = state.get(
+        instruction.value.lvalue.place.identifier.declarationId
+      );
+      return {
+        kind: 'replace',
+        value: {
+          kind: 'instruction',
+          instruction: Object.assign(Object.assign({}, instruction), {
+            value: Object.assign(Object.assign({}, instruction.value), {
+              lvalue: Object.assign(
+                Object.assign({}, instruction.value.lvalue),
+                {kind: kind}
+              ),
+              type: null,
+              kind: 'StoreLocal',
+            }),
+          }),
+        },
+      };
     }
-    buf.push(']');
-    return buf.length > 2 ? buf.join('\n') : buf.join('');
-  }
-}
-(_ReactiveScopeDependencyTree_roots = new WeakMap()),
-  (_ReactiveScopeDependencyTree_instances = new WeakSet()),
-  (_ReactiveScopeDependencyTree_getOrCreateRoot =
-    function _ReactiveScopeDependencyTree_getOrCreateRoot(identifier) {
-      let rootNode = __classPrivateFieldGet(
-        this,
-        _ReactiveScopeDependencyTree_roots,
-        'f'
-      ).get(identifier);
-      if (rootNode === undefined) {
-        rootNode = {
-          properties: new Map(),
-          accessType: PropertyAccessType$1.UnconditionalAccess,
-        };
-        __classPrivateFieldGet(
-          this,
-          _ReactiveScopeDependencyTree_roots,
-          'f'
-        ).set(identifier, rootNode);
-      }
-      return rootNode;
-    }),
-  (_ReactiveScopeDependencyTree_debugImpl =
-    function _ReactiveScopeDependencyTree_debugImpl(buf, node, depth = 0) {
-      for (const [property, childNode] of node.properties) {
-        buf.push(
-          `${'  '.repeat(depth)}.${property} (${childNode.accessType}):`
-        );
-        __classPrivateFieldGet(
-          this,
-          _ReactiveScopeDependencyTree_instances,
-          'm',
-          _ReactiveScopeDependencyTree_debugImpl
-        ).call(this, buf, childNode, depth + 1);
-      }
-    });
-var PropertyAccessType$1;
-(function (PropertyAccessType) {
-  PropertyAccessType['ConditionalAccess'] = 'ConditionalAccess';
-  PropertyAccessType['OptionalAccess'] = 'OptionalAccess';
-  PropertyAccessType['UnconditionalAccess'] = 'UnconditionalAccess';
-  PropertyAccessType['ConditionalDependency'] = 'ConditionalDependency';
-  PropertyAccessType['OptionalDependency'] = 'OptionalDependency';
-  PropertyAccessType['UnconditionalDependency'] = 'UnconditionalDependency';
-})(PropertyAccessType$1 || (PropertyAccessType$1 = {}));
-const MIN_ACCESS_TYPE = PropertyAccessType$1.ConditionalAccess;
-function isUnconditional(access) {
-  return (
-    access === PropertyAccessType$1.UnconditionalAccess ||
-    access === PropertyAccessType$1.UnconditionalDependency
-  );
-}
-function isDependency$1(access) {
-  return (
-    access === PropertyAccessType$1.ConditionalDependency ||
-    access === PropertyAccessType$1.OptionalDependency ||
-    access === PropertyAccessType$1.UnconditionalDependency
-  );
-}
-function isOptional$1(access) {
-  return (
-    access === PropertyAccessType$1.OptionalAccess ||
-    access === PropertyAccessType$1.OptionalDependency
-  );
-}
-function merge$1(access1, access2) {
-  const resultIsUnconditional =
-    isUnconditional(access1) || isUnconditional(access2);
-  const resultIsDependency = isDependency$1(access1) || isDependency$1(access2);
-  const resultIsOptional = isOptional$1(access1) || isOptional$1(access2);
-  if (resultIsUnconditional) {
-    if (resultIsDependency) {
-      return PropertyAccessType$1.UnconditionalDependency;
-    } else {
-      return PropertyAccessType$1.UnconditionalAccess;
-    }
-  } else if (resultIsOptional) {
-    if (resultIsDependency) {
-      return PropertyAccessType$1.OptionalDependency;
-    } else {
-      return PropertyAccessType$1.OptionalAccess;
-    }
-  } else {
-    if (resultIsDependency) {
-      return PropertyAccessType$1.ConditionalDependency;
-    } else {
-      return PropertyAccessType$1.ConditionalAccess;
-    }
-  }
-}
-function promoteResult(accessType, path) {
-  const result = {relativePath: [], accessType: accessType};
-  if (path !== null) {
-    result.relativePath.push(path);
-  }
-  return [result];
-}
-function prependPath(results, path) {
-  if (path === null) {
-    return results;
-  }
-  return results.map(result => ({
-    accessType: result.accessType,
-    relativePath: [path, ...result.relativePath],
-  }));
-}
-function deriveMinimalDependenciesInSubtree(dep, property) {
-  const results = [];
-  for (const [childName, childNode] of dep.properties) {
-    const childResult = deriveMinimalDependenciesInSubtree(
-      childNode,
-      childName
-    );
-    results.push(...childResult);
-  }
-  switch (dep.accessType) {
-    case PropertyAccessType$1.UnconditionalDependency: {
-      return promoteResult(
-        PropertyAccessType$1.UnconditionalDependency,
-        property !== null ? {property: property, optional: false} : null
-      );
-    }
-    case PropertyAccessType$1.UnconditionalAccess: {
-      if (
-        results.every(
-          ({accessType: accessType}) =>
-            accessType === PropertyAccessType$1.UnconditionalDependency ||
-            accessType === PropertyAccessType$1.OptionalDependency
-        )
-      ) {
-        return prependPath(
-          results,
-          property !== null ? {property: property, optional: false} : null
-        );
-      } else {
-        return promoteResult(
-          PropertyAccessType$1.UnconditionalDependency,
-          property !== null ? {property: property, optional: false} : null
-        );
-      }
-    }
-    case PropertyAccessType$1.OptionalDependency: {
-      return promoteResult(
-        PropertyAccessType$1.OptionalDependency,
-        property !== null ? {property: property, optional: true} : null
-      );
-    }
-    case PropertyAccessType$1.OptionalAccess: {
-      if (
-        results.every(
-          ({accessType: accessType}) =>
-            accessType === PropertyAccessType$1.UnconditionalDependency ||
-            accessType === PropertyAccessType$1.OptionalDependency
-        )
-      ) {
-        return prependPath(
-          results,
-          property !== null ? {property: property, optional: true} : null
-        );
-      } else {
-        return promoteResult(
-          PropertyAccessType$1.OptionalDependency,
-          property !== null ? {property: property, optional: true} : null
-        );
-      }
-    }
-    case PropertyAccessType$1.ConditionalAccess:
-    case PropertyAccessType$1.ConditionalDependency: {
-      if (
-        results.every(
-          ({accessType: accessType}) =>
-            accessType === PropertyAccessType$1.ConditionalDependency
-        )
-      ) {
-        return promoteResult(
-          PropertyAccessType$1.ConditionalDependency,
-          property !== null ? {property: property, optional: true} : null
-        );
-      } else {
-        return promoteResult(
-          PropertyAccessType$1.UnconditionalDependency,
-          property !== null ? {property: property, optional: true} : null
-        );
-      }
-    }
-    default: {
-      assertExhaustive(
-        dep.accessType,
-        '[PropgateScopeDependencies] Unhandled access type!'
-      );
-    }
-  }
-}
-function demoteSubtreeToConditional(subtree) {
-  const stack = [subtree];
-  let node;
-  while ((node = stack.pop()) !== undefined) {
-    const {accessType: accessType, properties: properties} = node;
-    if (!isUnconditional(accessType)) {
-      continue;
-    }
-    node.accessType = isDependency$1(accessType)
-      ? PropertyAccessType$1.ConditionalDependency
-      : PropertyAccessType$1.ConditionalAccess;
-    for (const childNode of properties.values()) {
-      if (isUnconditional(accessType)) {
-        stack.push(childNode);
-      }
-    }
-  }
-}
-function addSubtree(currNode, otherNode, demoteOtherNode) {
-  let otherType = otherNode.accessType;
-  if (demoteOtherNode) {
-    otherType = isDependency$1(otherType)
-      ? PropertyAccessType$1.ConditionalDependency
-      : PropertyAccessType$1.ConditionalAccess;
-  }
-  currNode.accessType = merge$1(currNode.accessType, otherType);
-  for (const [propertyName, otherChild] of otherNode.properties) {
-    const currChild = currNode.properties.get(propertyName);
-    if (currChild) {
-      addSubtree(currChild, otherChild, demoteOtherNode);
-    } else {
-      if (demoteOtherNode) {
-        demoteSubtreeToConditional(otherChild);
-      }
-      currNode.properties.set(propertyName, otherChild);
-    }
-  }
-}
-function addSubtreeIntersection(currProperties, otherProperties) {
-  CompilerError.invariant(otherProperties.length > 1, {
-    reason:
-      '[DeriveMinimalDependencies] Expected otherProperties to be at least 2 elements long.',
-    description: null,
-    loc: null,
-    suggestions: null,
-  });
-  for (const [propertyName, currNode] of currProperties) {
-    const otherNodes = mapNonNull(otherProperties, properties => {
-      const node = properties.get(propertyName);
-      if (node != null && isUnconditional(node.accessType)) {
-        return node;
-      } else {
-        return null;
-      }
-    });
-    if (otherNodes) {
-      addSubtreeIntersection(
-        currNode.properties,
-        otherNodes.map(node => node.properties)
-      );
-      const isDep = otherNodes.some(tree => isDependency$1(tree.accessType));
-      const externalAccessType = isDep
-        ? PropertyAccessType$1.UnconditionalDependency
-        : PropertyAccessType$1.UnconditionalAccess;
-      currNode.accessType = merge$1(externalAccessType, currNode.accessType);
-    }
-  }
-}
-function printSubtree$1(node, includeAccesses) {
-  const results = [];
-  for (const [propertyName, propertyNode] of node.properties) {
-    if (includeAccesses || isDependency$1(propertyNode.accessType)) {
-      results.push(`${propertyName} (${propertyNode.accessType})`);
-    }
-    const propertyResults = printSubtree$1(propertyNode, includeAccesses);
-    results.push(...propertyResults.map(result => `${propertyName}.${result}`));
-  }
-  return results;
-}
-function getOrMakeProperty(node, property) {
-  let child = node.properties.get(property);
-  if (child == null) {
-    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE};
-    node.properties.set(property, child);
-  }
-  return child;
-}
-function mapNonNull(arr, fn) {
-  const result = [];
-  for (let i = 0; i < arr.length; i++) {
-    const element = fn(arr[i]);
-    if (element) {
-      result.push(element);
-    } else {
-      return null;
-    }
-  }
-  return result;
-}
-var _PoisonState_instances,
-  _PoisonState_invalidate,
-  _Context_instances$1,
-  _Context_temporariesUsedOutsideScope$1,
-  _Context_declarations$1,
-  _Context_reassignments$1,
-  _Context_dependencies$1,
-  _Context_properties,
-  _Context_temporaries$1,
-  _Context_inConditionalWithinScope,
-  _Context_depsInCurrentConditional,
-  _Context_scopes$1,
-  _Context_getProperty,
-  _Context_checkValidDependency$1,
-  _Context_isScopeActive$1;
-function propagateScopeDependencies(fn) {
-  const escapingTemporaries = {
-    declarations: new Map(),
-    usedOutsideDeclaringScope: new Set(),
-  };
-  visitReactiveFunction(fn, new FindPromotedTemporaries(), escapingTemporaries);
-  const context = new Context$1(escapingTemporaries.usedOutsideDeclaringScope);
-  for (const param of fn.params) {
-    if (param.kind === 'Identifier') {
-      context.declare(param.identifier, {
-        id: makeInstructionId(0),
-        scope: empty(),
-      });
-    } else {
-      context.declare(param.place.identifier, {
-        id: makeInstructionId(0),
-        scope: empty(),
-      });
-    }
-  }
-  visitReactiveFunction(fn, new PropagationVisitor(fn.env), context);
-}
-class FindPromotedTemporaries extends ReactiveFunctionVisitor {
-  constructor() {
-    super(...arguments);
-    this.scopes = [];
-  }
-  visitScope(scope, state) {
-    this.scopes.push(scope.scope.id);
-    this.traverseScope(scope, state);
-    this.scopes.pop();
-  }
-  visitInstruction(instruction, state) {
-    this.traverseInstruction(instruction, state);
-    const scope = this.scopes.at(-1);
-    if (instruction.lvalue === null || scope === undefined) {
-      return;
-    }
-    switch (instruction.value.kind) {
-      case 'LoadLocal':
-      case 'LoadContext':
-      case 'PropertyLoad': {
-        state.declarations.set(
-          instruction.lvalue.identifier.declarationId,
-          scope
-        );
-        break;
-      }
-    }
-  }
-  visitPlace(_id, place, state) {
-    const declaringScope = state.declarations.get(
-      place.identifier.declarationId
-    );
-    if (declaringScope === undefined) {
-      return;
-    }
-    if (this.scopes.indexOf(declaringScope) === -1) {
-      state.usedOutsideDeclaringScope.add(place.identifier.declarationId);
-    }
-  }
-}
-class PoisonState {
-  constructor(poisonedBlocks, poisonedScopes, isPoisoned) {
-    _PoisonState_instances.add(this);
-    this.poisonedBlocks = new Set();
-    this.poisonedScopes = new Set();
-    this.isPoisoned = false;
-    this.poisonedBlocks = poisonedBlocks;
-    this.poisonedScopes = poisonedScopes;
-    this.isPoisoned = isPoisoned;
-  }
-  clone() {
-    return new PoisonState(
-      new Set(this.poisonedBlocks),
-      new Set(this.poisonedScopes),
-      this.isPoisoned
-    );
-  }
-  take(other) {
-    const copy = new PoisonState(
-      this.poisonedBlocks,
-      this.poisonedScopes,
-      this.isPoisoned
-    );
-    this.poisonedBlocks = other.poisonedBlocks;
-    this.poisonedScopes = other.poisonedScopes;
-    this.isPoisoned = other.isPoisoned;
-    return copy;
-  }
-  merge(others, currentScope) {
-    for (const other of others) {
-      for (const id of other.poisonedBlocks) {
-        this.poisonedBlocks.add(id);
-      }
-      for (const id of other.poisonedScopes) {
-        this.poisonedScopes.add(id);
-      }
-    }
-    __classPrivateFieldGet(
-      this,
-      _PoisonState_instances,
-      'm',
-      _PoisonState_invalidate
-    ).call(this, currentScope);
-  }
-  addPoisonTarget(target, activeScopes) {
-    const currentScope = activeScopes.value;
-    if (target == null && currentScope != null) {
-      let cursor = activeScopes;
-      while (true) {
-        const next = cursor.pop();
-        if (next.value == null) {
-          const poisonedScope = cursor.value.value.id;
-          this.poisonedScopes.add(poisonedScope);
-          if (
-            poisonedScope ===
-            (currentScope === null || currentScope === void 0
-              ? void 0
-              : currentScope.value.id)
-          ) {
-            this.isPoisoned = true;
-          }
-          break;
-        } else {
-          cursor = next;
-        }
-      }
-    } else if (target != null) {
-      this.poisonedBlocks.add(target);
-      if (
-        !this.isPoisoned &&
-        (currentScope === null || currentScope === void 0
-          ? void 0
-          : currentScope.ownBlocks.find(blockId => blockId === target))
-      ) {
-        this.isPoisoned = true;
-      }
-    }
-  }
-  removeMaybePoisonedScope(id, currentScope) {
-    this.poisonedScopes.delete(id);
-    __classPrivateFieldGet(
-      this,
-      _PoisonState_instances,
-      'm',
-      _PoisonState_invalidate
-    ).call(this, currentScope);
-  }
-  removeMaybePoisonedBlock(id, currentScope) {
-    this.poisonedBlocks.delete(id);
-    __classPrivateFieldGet(
-      this,
-      _PoisonState_instances,
-      'm',
-      _PoisonState_invalidate
-    ).call(this, currentScope);
-  }
-}
-(_PoisonState_instances = new WeakSet()),
-  (_PoisonState_invalidate = function _PoisonState_invalidate(currentScope) {
-    if (currentScope != null) {
-      if (this.poisonedScopes.has(currentScope.value.id)) {
-        this.isPoisoned = true;
-        return;
-      } else if (
-        currentScope.ownBlocks.find(blockId => this.poisonedBlocks.has(blockId))
-      ) {
-        this.isPoisoned = true;
-        return;
-      }
-    }
-    this.isPoisoned = false;
-  });
-let Context$1 = class Context {
-  constructor(temporariesUsedOutsideScope) {
-    _Context_instances$1.add(this);
-    _Context_temporariesUsedOutsideScope$1.set(this, void 0);
-    _Context_declarations$1.set(this, new Map());
-    _Context_reassignments$1.set(this, new Map());
-    _Context_dependencies$1.set(this, new ReactiveScopeDependencyTree());
-    _Context_properties.set(this, new Map());
-    _Context_temporaries$1.set(this, new Map());
-    _Context_inConditionalWithinScope.set(this, false);
-    _Context_depsInCurrentConditional.set(
-      this,
-      new ReactiveScopeDependencyTree()
-    );
-    _Context_scopes$1.set(this, empty());
-    this.poisonState = new PoisonState(new Set(), new Set(), false);
-    __classPrivateFieldSet(
-      this,
-      _Context_temporariesUsedOutsideScope$1,
-      temporariesUsedOutsideScope,
-      'f'
-    );
-  }
-  enter(scope, fn) {
-    const prevInConditional = __classPrivateFieldGet(
-      this,
-      _Context_inConditionalWithinScope,
-      'f'
-    );
-    const previousDependencies = __classPrivateFieldGet(
-      this,
-      _Context_dependencies$1,
-      'f'
-    );
-    const prevDepsInConditional = this.isPoisoned
-      ? __classPrivateFieldGet(this, _Context_depsInCurrentConditional, 'f')
-      : null;
-    if (prevDepsInConditional != null) {
-      __classPrivateFieldSet(
-        this,
-        _Context_depsInCurrentConditional,
-        new ReactiveScopeDependencyTree(),
-        'f'
-      );
-    }
-    const scopedDependencies = new ReactiveScopeDependencyTree();
-    __classPrivateFieldSet(this, _Context_inConditionalWithinScope, false, 'f');
-    __classPrivateFieldSet(
-      this,
-      _Context_dependencies$1,
-      scopedDependencies,
-      'f'
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_scopes$1,
-      __classPrivateFieldGet(this, _Context_scopes$1, 'f').push({
-        value: scope,
-        ownBlocks: empty(),
-      }),
-      'f'
-    );
-    this.poisonState.isPoisoned = false;
-    fn();
-    __classPrivateFieldSet(
-      this,
-      _Context_scopes$1,
-      __classPrivateFieldGet(this, _Context_scopes$1, 'f').pop(),
-      'f'
-    );
-    this.poisonState.removeMaybePoisonedScope(
-      scope.id,
-      __classPrivateFieldGet(this, _Context_scopes$1, 'f').value
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_dependencies$1,
-      previousDependencies,
-      'f'
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_inConditionalWithinScope,
-      prevInConditional,
-      'f'
-    );
-    const minInnerScopeDependencies =
-      scopedDependencies.deriveMinimalDependencies();
-    __classPrivateFieldGet(
-      this,
-      _Context_dependencies$1,
-      'f'
-    ).addDepsFromInnerScope(
-      scopedDependencies,
-      __classPrivateFieldGet(this, _Context_inConditionalWithinScope, 'f') ||
-        this.isPoisoned,
-      __classPrivateFieldGet(
-        this,
-        _Context_instances$1,
-        'm',
-        _Context_checkValidDependency$1
-      ).bind(this)
-    );
-    if (prevDepsInConditional != null) {
-      prevDepsInConditional.addDepsFromInnerScope(
-        __classPrivateFieldGet(this, _Context_depsInCurrentConditional, 'f'),
-        true,
-        __classPrivateFieldGet(
-          this,
-          _Context_instances$1,
-          'm',
-          _Context_checkValidDependency$1
-        ).bind(this)
-      );
-      __classPrivateFieldSet(
-        this,
-        _Context_depsInCurrentConditional,
-        prevDepsInConditional,
-        'f'
-      );
-    }
-    return minInnerScopeDependencies;
-  }
-  isUsedOutsideDeclaringScope(place) {
-    return __classPrivateFieldGet(
-      this,
-      _Context_temporariesUsedOutsideScope$1,
-      'f'
-    ).has(place.identifier.declarationId);
-  }
-  printDeps(includeAccesses = false) {
-    return __classPrivateFieldGet(this, _Context_dependencies$1, 'f').printDeps(
-      includeAccesses
-    );
-  }
-  enterConditional(fn) {
-    const prevInConditional = __classPrivateFieldGet(
-      this,
-      _Context_inConditionalWithinScope,
-      'f'
-    );
-    const prevUncondAccessed = __classPrivateFieldGet(
-      this,
-      _Context_depsInCurrentConditional,
-      'f'
-    );
-    __classPrivateFieldSet(this, _Context_inConditionalWithinScope, true, 'f');
-    __classPrivateFieldSet(
-      this,
-      _Context_depsInCurrentConditional,
-      new ReactiveScopeDependencyTree(),
-      'f'
-    );
-    fn();
-    const result = __classPrivateFieldGet(
-      this,
-      _Context_depsInCurrentConditional,
-      'f'
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_inConditionalWithinScope,
-      prevInConditional,
-      'f'
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_depsInCurrentConditional,
-      prevUncondAccessed,
-      'f'
-    );
-    return result;
-  }
-  promoteDepsFromExhaustiveConditionals(depsInConditionals) {
-    __classPrivateFieldGet(
-      this,
-      _Context_dependencies$1,
-      'f'
-    ).promoteDepsFromExhaustiveConditionals(depsInConditionals);
-    __classPrivateFieldGet(
-      this,
-      _Context_depsInCurrentConditional,
-      'f'
-    ).promoteDepsFromExhaustiveConditionals(depsInConditionals);
-  }
-  declare(identifier, decl) {
-    if (
-      !__classPrivateFieldGet(this, _Context_declarations$1, 'f').has(
-        identifier.declarationId
-      )
-    ) {
-      __classPrivateFieldGet(this, _Context_declarations$1, 'f').set(
-        identifier.declarationId,
-        decl
-      );
-    }
-    __classPrivateFieldGet(this, _Context_reassignments$1, 'f').set(
-      identifier,
-      decl
-    );
-  }
-  declareTemporary(lvalue, place) {
-    __classPrivateFieldGet(this, _Context_temporaries$1, 'f').set(
-      lvalue.identifier,
-      place
-    );
-  }
-  resolveTemporary(place) {
-    var _a;
-    return (_a = __classPrivateFieldGet(this, _Context_temporaries$1, 'f').get(
-      place.identifier
-    )) !== null && _a !== void 0
-      ? _a
-      : place;
-  }
-  declareProperty(lvalue, object, property, optional) {
-    const nextDependency = __classPrivateFieldGet(
-      this,
-      _Context_instances$1,
-      'm',
-      _Context_getProperty
-    ).call(this, object, property, optional);
-    __classPrivateFieldGet(this, _Context_properties, 'f').set(
-      lvalue.identifier,
-      nextDependency
-    );
-  }
-  get currentScope() {
-    return __classPrivateFieldGet(this, _Context_scopes$1, 'f');
-  }
-  get isPoisoned() {
-    return this.poisonState.isPoisoned;
-  }
-  visitOperand(place) {
-    const resolved = this.resolveTemporary(place);
-    let dependency = {identifier: resolved.identifier, path: []};
-    if (resolved.identifier.name === null) {
-      const propertyDependency = __classPrivateFieldGet(
-        this,
-        _Context_properties,
-        'f'
-      ).get(resolved.identifier);
-      if (propertyDependency !== undefined) {
-        dependency = Object.assign({}, propertyDependency);
-      }
-    }
-    this.visitDependency(dependency);
-  }
-  visitProperty(object, property, optional) {
-    const nextDependency = __classPrivateFieldGet(
-      this,
-      _Context_instances$1,
-      'm',
-      _Context_getProperty
-    ).call(this, object, property, optional);
-    this.visitDependency(nextDependency);
-  }
-  visitDependency(maybeDependency) {
-    const originalDeclaration = __classPrivateFieldGet(
-      this,
-      _Context_declarations$1,
-      'f'
-    ).get(maybeDependency.identifier.declarationId);
-    if (
-      originalDeclaration !== undefined &&
-      originalDeclaration.scope.value !== null
-    ) {
-      originalDeclaration.scope.each(scope => {
-        if (
-          !__classPrivateFieldGet(
-            this,
-            _Context_instances$1,
-            'm',
-            _Context_isScopeActive$1
-          ).call(this, scope.value) &&
-          !Iterable_some(
-            scope.value.declarations.values(),
-            decl =>
-              decl.identifier.declarationId ===
-              maybeDependency.identifier.declarationId
-          )
-        ) {
-          scope.value.declarations.set(maybeDependency.identifier.id, {
-            identifier: maybeDependency.identifier,
-            scope: originalDeclaration.scope.value.value,
-          });
-        }
-      });
-    }
-    if (
-      __classPrivateFieldGet(
-        this,
-        _Context_instances$1,
-        'm',
-        _Context_checkValidDependency$1
-      ).call(this, maybeDependency)
-    ) {
-      const isPoisoned = this.isPoisoned;
-      __classPrivateFieldGet(this, _Context_depsInCurrentConditional, 'f').add(
-        maybeDependency,
-        isPoisoned
-      );
-      __classPrivateFieldGet(this, _Context_dependencies$1, 'f').add(
-        maybeDependency,
-        __classPrivateFieldGet(this, _Context_inConditionalWithinScope, 'f') ||
-          isPoisoned
-      );
-    }
-  }
-  visitReassignment(place) {
-    var _a;
-    const currentScope =
-      (_a = this.currentScope.value) === null || _a === void 0
-        ? void 0
-        : _a.value;
-    if (
-      currentScope != null &&
-      !Iterable_some(
-        currentScope.reassignments,
-        identifier =>
-          identifier.declarationId === place.identifier.declarationId
-      ) &&
-      __classPrivateFieldGet(
-        this,
-        _Context_instances$1,
-        'm',
-        _Context_checkValidDependency$1
-      ).call(this, {identifier: place.identifier, path: []})
-    ) {
-      currentScope.reassignments.add(place.identifier);
-    }
-  }
-  pushLabeledBlock(id) {
-    const currentScope = __classPrivateFieldGet(
-      this,
-      _Context_scopes$1,
-      'f'
-    ).value;
-    if (currentScope != null) {
-      currentScope.ownBlocks = currentScope.ownBlocks.push(id);
-    }
-  }
-  popLabeledBlock(id) {
-    const currentScope = __classPrivateFieldGet(
-      this,
-      _Context_scopes$1,
-      'f'
-    ).value;
-    if (currentScope != null) {
-      const last = currentScope.ownBlocks.value;
-      currentScope.ownBlocks = currentScope.ownBlocks.pop();
-      CompilerError.invariant(last != null && last === id, {
-        reason: '[PropagateScopeDependencies] Misformed block stack',
-        loc: GeneratedSource,
-      });
-    }
-    this.poisonState.removeMaybePoisonedBlock(id, currentScope);
-  }
-};
-(_Context_temporariesUsedOutsideScope$1 = new WeakMap()),
-  (_Context_declarations$1 = new WeakMap()),
-  (_Context_reassignments$1 = new WeakMap()),
-  (_Context_dependencies$1 = new WeakMap()),
-  (_Context_properties = new WeakMap()),
-  (_Context_temporaries$1 = new WeakMap()),
-  (_Context_inConditionalWithinScope = new WeakMap()),
-  (_Context_depsInCurrentConditional = new WeakMap()),
-  (_Context_scopes$1 = new WeakMap()),
-  (_Context_instances$1 = new WeakSet()),
-  (_Context_getProperty = function _Context_getProperty(
-    object,
-    property,
-    optional
-  ) {
-    const resolvedObject = this.resolveTemporary(object);
-    const resolvedDependency = __classPrivateFieldGet(
-      this,
-      _Context_properties,
-      'f'
-    ).get(resolvedObject.identifier);
-    let objectDependency;
-    if (resolvedDependency === undefined) {
-      objectDependency = {identifier: resolvedObject.identifier, path: []};
-    } else {
-      objectDependency = {
-        identifier: resolvedDependency.identifier,
-        path: [...resolvedDependency.path],
-      };
-    }
-    objectDependency.path.push({property: property, optional: optional});
-    return objectDependency;
-  }),
-  (_Context_checkValidDependency$1 = function _Context_checkValidDependency(
-    maybeDependency
-  ) {
-    var _a, _b, _c, _d;
-    if (
-      isUseRefType(maybeDependency.identifier) &&
-      ((_a = maybeDependency.path.at(0)) === null || _a === void 0
-        ? void 0
-        : _a.property) === 'current'
-    ) {
-      return false;
-    }
-    if (isRefValueType(maybeDependency.identifier)) {
-      return false;
-    }
-    if (isObjectMethodType(maybeDependency.identifier)) {
-      return false;
-    }
-    const identifier = maybeDependency.identifier;
-    const currentDeclaration =
-      (_b = __classPrivateFieldGet(this, _Context_reassignments$1, 'f').get(
-        identifier
-      )) !== null && _b !== void 0
-        ? _b
-        : __classPrivateFieldGet(this, _Context_declarations$1, 'f').get(
-            identifier.declarationId
-          );
-    const currentScope =
-      (_c = this.currentScope.value) === null || _c === void 0
-        ? void 0
-        : _c.value;
-    return (
-      currentScope != null &&
-      currentDeclaration !== undefined &&
-      currentDeclaration.id < currentScope.range.start &&
-      (currentDeclaration.scope == null ||
-        ((_d = currentDeclaration.scope.value) === null || _d === void 0
-          ? void 0
-          : _d.value) !== currentScope)
-    );
-  }),
-  (_Context_isScopeActive$1 = function _Context_isScopeActive(scope) {
-    if (__classPrivateFieldGet(this, _Context_scopes$1, 'f') === null) {
-      return false;
-    }
-    return __classPrivateFieldGet(this, _Context_scopes$1, 'f').find(
-      state => state.value === scope
-    );
-  });
-class PropagationVisitor extends ReactiveFunctionVisitor {
-  constructor(env) {
-    super();
-    this.env = env;
-  }
-  visitScope(scope, context) {
-    const scopeDependencies = context.enter(scope.scope, () => {
-      this.visitBlock(scope.instructions, context);
-    });
-    for (const candidateDep of scopeDependencies) {
-      if (
-        !Iterable_some(
-          scope.scope.dependencies,
-          existingDep =>
-            existingDep.identifier.declarationId ===
-              candidateDep.identifier.declarationId &&
-            areEqualPaths(existingDep.path, candidateDep.path)
-        )
-      ) {
-        scope.scope.dependencies.add(candidateDep);
-      }
-    }
-  }
-  visitPrunedScope(scopeBlock, context) {
-    context.enter(scopeBlock.scope, () => {
-      this.visitBlock(scopeBlock.instructions, context);
-    });
-  }
-  visitInstruction(instruction, context) {
-    const {id: id, value: value, lvalue: lvalue} = instruction;
-    this.visitInstructionValue(context, id, value, lvalue);
-    if (lvalue == null) {
-      return;
-    }
-    context.declare(lvalue.identifier, {id: id, scope: context.currentScope});
-  }
-  extractOptionalProperty(context, optionalValue, lvalue) {
-    const sequence = optionalValue.value;
-    CompilerError.invariant(sequence.kind === 'SequenceExpression', {
-      reason: 'Expected OptionalExpression value to be a SequenceExpression',
-      description: `Found a \`${sequence.kind}\``,
-      loc: sequence.loc,
-    });
-    if (
-      sequence.instructions.length === 1 &&
-      sequence.instructions[0].lvalue !== null &&
-      sequence.instructions[0].value.kind === 'LoadLocal' &&
-      sequence.instructions[0].value.place.identifier.name !== null &&
-      !context.isUsedOutsideDeclaringScope(sequence.instructions[0].lvalue) &&
-      sequence.value.kind === 'SequenceExpression' &&
-      sequence.value.instructions.length === 1 &&
-      sequence.value.instructions[0].value.kind === 'PropertyLoad' &&
-      sequence.value.instructions[0].value.object.identifier.id ===
-        sequence.instructions[0].lvalue.identifier.id &&
-      sequence.value.instructions[0].lvalue !== null &&
-      sequence.value.value.kind === 'LoadLocal' &&
-      sequence.value.value.place.identifier.id ===
-        sequence.value.instructions[0].lvalue.identifier.id
-    ) {
-      context.declareTemporary(
-        sequence.instructions[0].lvalue,
-        sequence.instructions[0].value.place
-      );
-      const propertyLoad = sequence.value.instructions[0].value;
-      return {
-        lvalue: lvalue,
-        object: propertyLoad.object,
-        property: propertyLoad.property,
-        optional: optionalValue.optional,
-      };
-    }
-    if (
-      sequence.instructions.length === 1 &&
-      sequence.instructions[0].lvalue !== null &&
-      sequence.instructions[0].value.kind === 'SequenceExpression' &&
-      sequence.instructions[0].value.instructions.length === 1 &&
-      sequence.instructions[0].value.instructions[0].lvalue !== null &&
-      sequence.instructions[0].value.instructions[0].value.kind ===
-        'LoadLocal' &&
-      sequence.instructions[0].value.instructions[0].value.place.identifier
-        .name !== null &&
-      !context.isUsedOutsideDeclaringScope(
-        sequence.instructions[0].value.instructions[0].lvalue
-      ) &&
-      sequence.instructions[0].value.value.kind === 'PropertyLoad' &&
-      sequence.instructions[0].value.value.object.identifier.id ===
-        sequence.instructions[0].value.instructions[0].lvalue.identifier.id &&
-      sequence.value.kind === 'SequenceExpression' &&
-      sequence.value.instructions.length === 1 &&
-      sequence.value.instructions[0].lvalue !== null &&
-      sequence.value.instructions[0].value.kind === 'PropertyLoad' &&
-      sequence.value.instructions[0].value.object.identifier.id ===
-        sequence.instructions[0].lvalue.identifier.id &&
-      sequence.value.value.kind === 'LoadLocal' &&
-      sequence.value.value.place.identifier.id ===
-        sequence.value.instructions[0].lvalue.identifier.id
-    ) {
-      context.declareTemporary(
-        sequence.instructions[0].value.instructions[0].lvalue,
-        sequence.instructions[0].value.instructions[0].value.place
-      );
-      context.declareProperty(
-        sequence.instructions[0].lvalue,
-        sequence.instructions[0].value.value.object,
-        sequence.instructions[0].value.value.property,
-        false
-      );
-      const propertyLoad = sequence.value.instructions[0].value;
-      return {
-        lvalue: lvalue,
-        object: propertyLoad.object,
-        property: propertyLoad.property,
-        optional: optionalValue.optional,
-      };
-    }
-    if (
-      sequence.instructions.length === 1 &&
-      sequence.instructions[0].value.kind === 'SequenceExpression' &&
-      sequence.instructions[0].value.instructions.length === 1 &&
-      sequence.instructions[0].value.instructions[0].lvalue !== null &&
-      sequence.instructions[0].value.instructions[0].value.kind ===
-        'OptionalExpression' &&
-      sequence.instructions[0].value.value.kind === 'LoadLocal' &&
-      sequence.instructions[0].value.value.place.identifier.id ===
-        sequence.instructions[0].value.instructions[0].lvalue.identifier.id &&
-      sequence.value.kind === 'SequenceExpression' &&
-      sequence.value.instructions.length === 1 &&
-      sequence.value.instructions[0].lvalue !== null &&
-      sequence.value.instructions[0].value.kind === 'PropertyLoad' &&
-      sequence.value.instructions[0].value.object.identifier.id ===
-        sequence.instructions[0].value.value.place.identifier.id &&
-      sequence.value.value.kind === 'LoadLocal' &&
-      sequence.value.value.place.identifier.id ===
-        sequence.value.instructions[0].lvalue.identifier.id
-    ) {
-      const {lvalue: innerLvalue, value: innerOptional} =
-        sequence.instructions[0].value.instructions[0];
-      const innerProperty = this.extractOptionalProperty(
-        context,
-        innerOptional,
-        innerLvalue
-      );
-      if (innerProperty === null) {
-        return null;
-      }
-      context.declareProperty(
-        innerProperty.lvalue,
-        innerProperty.object,
-        innerProperty.property,
-        innerProperty.optional
-      );
-      const propertyLoad = sequence.value.instructions[0].value;
-      return {
-        lvalue: lvalue,
-        object: propertyLoad.object,
-        property: propertyLoad.property,
-        optional: optionalValue.optional,
-      };
-    }
-    return null;
-  }
-  visitOptionalExpression(context, id, value, lvalue) {
-    if (
-      lvalue !== null &&
-      value.optional &&
-      this.env.config.enableOptionalDependencies
-    ) {
-      const inner = this.extractOptionalProperty(context, value, lvalue);
-      if (inner !== null) {
-        context.visitProperty(inner.object, inner.property, inner.optional);
-        return;
-      }
-    }
-    const inner = value.value;
-    CompilerError.invariant(inner.kind === 'SequenceExpression', {
-      reason: 'Expected OptionalExpression value to be a SequenceExpression',
-      description: `Found a \`${value.kind}\``,
-      loc: value.loc,
-      suggestions: null,
-    });
-    for (const instr of inner.instructions) {
-      this.visitInstruction(instr, context);
-    }
-    context.enterConditional(() => {
-      this.visitReactiveValue(context, id, inner.value, null);
-    });
-  }
-  visitReactiveValue(context, id, value, lvalue) {
-    switch (value.kind) {
-      case 'OptionalExpression': {
-        this.visitOptionalExpression(context, id, value, lvalue);
-        break;
-      }
-      case 'LogicalExpression': {
-        this.visitReactiveValue(context, id, value.left, null);
-        context.enterConditional(() => {
-          this.visitReactiveValue(context, id, value.right, null);
-        });
-        break;
-      }
-      case 'ConditionalExpression': {
-        this.visitReactiveValue(context, id, value.test, null);
-        const consequentDeps = context.enterConditional(() => {
-          this.visitReactiveValue(context, id, value.consequent, null);
-        });
-        const alternateDeps = context.enterConditional(() => {
-          this.visitReactiveValue(context, id, value.alternate, null);
-        });
-        context.promoteDepsFromExhaustiveConditionals([
-          consequentDeps,
-          alternateDeps,
-        ]);
-        break;
-      }
-      case 'SequenceExpression': {
-        for (const instr of value.instructions) {
-          this.visitInstruction(instr, context);
-        }
-        this.visitInstructionValue(context, id, value.value, null);
-        break;
-      }
-      case 'FunctionExpression': {
-        if (this.env.config.enableTreatFunctionDepsAsConditional) {
-          context.enterConditional(() => {
-            for (const operand of eachInstructionValueOperand(value)) {
-              context.visitOperand(operand);
-            }
-          });
-        } else {
-          for (const operand of eachInstructionValueOperand(value)) {
-            context.visitOperand(operand);
-          }
-        }
-        break;
-      }
-      case 'ReactiveFunctionValue': {
-        CompilerError.invariant(false, {
-          reason: `Unexpected ReactiveFunctionValue`,
-          loc: value.loc,
-          description: null,
-          suggestions: null,
-        });
-      }
-      default: {
-        for (const operand of eachInstructionValueOperand(value)) {
-          context.visitOperand(operand);
-        }
-      }
-    }
-  }
-  visitInstructionValue(context, id, value, lvalue) {
-    if (value.kind === 'LoadLocal' && lvalue !== null) {
-      if (
-        value.place.identifier.name !== null &&
-        lvalue.identifier.name === null &&
-        !context.isUsedOutsideDeclaringScope(lvalue)
-      ) {
-        context.declareTemporary(lvalue, value.place);
-      } else {
-        context.visitOperand(value.place);
-      }
-    } else if (value.kind === 'PropertyLoad') {
-      if (lvalue !== null && !context.isUsedOutsideDeclaringScope(lvalue)) {
-        context.declareProperty(lvalue, value.object, value.property, false);
-      } else {
-        context.visitProperty(value.object, value.property, false);
-      }
-    } else if (value.kind === 'StoreLocal') {
-      context.visitOperand(value.value);
-      if (value.lvalue.kind === InstructionKind.Reassign) {
-        context.visitReassignment(value.lvalue.place);
-      }
-      context.declare(value.lvalue.place.identifier, {
-        id: id,
-        scope: context.currentScope,
-      });
-    } else if (
-      value.kind === 'DeclareLocal' ||
-      value.kind === 'DeclareContext'
-    ) {
-      context.declare(value.lvalue.place.identifier, {
-        id: id,
-        scope: context.currentScope,
-      });
-    } else if (value.kind === 'Destructure') {
-      context.visitOperand(value.value);
-      for (const place of eachPatternOperand(value.lvalue.pattern)) {
-        if (value.lvalue.kind === InstructionKind.Reassign) {
-          context.visitReassignment(place);
-        }
-        context.declare(place.identifier, {
-          id: id,
-          scope: context.currentScope,
-        });
-      }
-    } else {
-      this.visitReactiveValue(context, id, value, lvalue);
-    }
-  }
-  enterTerminal(stmt, context) {
-    if (stmt.label != null) {
-      context.pushLabeledBlock(stmt.label.id);
-    }
-    const terminal = stmt.terminal;
-    switch (terminal.kind) {
-      case 'continue':
-      case 'break': {
-        context.poisonState.addPoisonTarget(
-          terminal.target,
-          context.currentScope
-        );
-        break;
-      }
-      case 'throw':
-      case 'return': {
-        context.poisonState.addPoisonTarget(null, context.currentScope);
-        break;
-      }
-    }
-  }
-  exitTerminal(stmt, context) {
-    if (stmt.label != null) {
-      context.popLabeledBlock(stmt.label.id);
-    }
-  }
-  visitTerminal(stmt, context) {
-    this.enterTerminal(stmt, context);
-    const terminal = stmt.terminal;
-    switch (terminal.kind) {
-      case 'break':
-      case 'continue': {
-        break;
-      }
-      case 'return': {
-        context.visitOperand(terminal.value);
-        break;
-      }
-      case 'throw': {
-        context.visitOperand(terminal.value);
-        break;
-      }
-      case 'for': {
-        this.visitReactiveValue(context, terminal.id, terminal.init, null);
-        this.visitReactiveValue(context, terminal.id, terminal.test, null);
-        context.enterConditional(() => {
-          this.visitBlock(terminal.loop, context);
-          if (terminal.update !== null) {
-            this.visitReactiveValue(
-              context,
-              terminal.id,
-              terminal.update,
-              null
-            );
-          }
-        });
-        break;
-      }
-      case 'for-of': {
-        this.visitReactiveValue(context, terminal.id, terminal.init, null);
-        context.enterConditional(() => {
-          this.visitBlock(terminal.loop, context);
-        });
-        break;
-      }
-      case 'for-in': {
-        this.visitReactiveValue(context, terminal.id, terminal.init, null);
-        context.enterConditional(() => {
-          this.visitBlock(terminal.loop, context);
-        });
-        break;
-      }
-      case 'do-while': {
-        this.visitBlock(terminal.loop, context);
-        context.enterConditional(() => {
-          this.visitReactiveValue(context, terminal.id, terminal.test, null);
-        });
-        break;
-      }
-      case 'while': {
-        this.visitReactiveValue(context, terminal.id, terminal.test, null);
-        context.enterConditional(() => {
-          this.visitBlock(terminal.loop, context);
-        });
-        break;
-      }
-      case 'if': {
-        context.visitOperand(terminal.test);
-        const {consequent: consequent, alternate: alternate} = terminal;
-        const prevPoisonState = context.poisonState.clone();
-        const depsInIf = context.enterConditional(() => {
-          this.visitBlock(consequent, context);
-        });
-        if (alternate !== null) {
-          const ifPoisonState = context.poisonState.take(prevPoisonState);
-          const depsInElse = context.enterConditional(() => {
-            this.visitBlock(alternate, context);
-          });
-          context.poisonState.merge(
-            [ifPoisonState],
-            context.currentScope.value
-          );
-          context.promoteDepsFromExhaustiveConditionals([depsInIf, depsInElse]);
-        }
-        break;
-      }
-      case 'switch': {
-        context.visitOperand(terminal.test);
-        const isDefaultOnly =
-          terminal.cases.length === 1 && terminal.cases[0].test == null;
-        if (isDefaultOnly) {
-          const case_ = terminal.cases[0];
-          if (case_.block != null) {
-            this.visitBlock(case_.block, context);
-            break;
-          }
-        }
-        const depsInCases = [];
-        let foundDefault = false;
-        const prevPoisonState = context.poisonState.clone();
-        const mutExPoisonStates = [];
-        for (const {test: test, block: block} of terminal.cases) {
-          if (test !== null) {
-            context.visitOperand(test);
-          } else {
-            foundDefault = true;
-          }
-          if (block !== undefined) {
-            mutExPoisonStates.push(
-              context.poisonState.take(prevPoisonState.clone())
-            );
-            depsInCases.push(
-              context.enterConditional(() => {
-                this.visitBlock(block, context);
-              })
-            );
-          }
-        }
-        if (foundDefault) {
-          context.promoteDepsFromExhaustiveConditionals(depsInCases);
-        }
-        context.poisonState.merge(
-          mutExPoisonStates,
-          context.currentScope.value
-        );
-        break;
-      }
-      case 'label': {
-        this.visitBlock(terminal.block, context);
-        break;
-      }
-      case 'try': {
-        this.visitBlock(terminal.block, context);
-        this.visitBlock(terminal.handler, context);
-        break;
-      }
-      default: {
-        assertExhaustive(
-          terminal,
-          `Unexpected terminal kind \`${terminal.kind}\``
-        );
-      }
-    }
-    this.exitTerminal(stmt, context);
-  }
-}
-function pruneHoistedContexts(fn) {
-  const hoistedIdentifiers = new Map();
-  visitReactiveFunction(fn, new Visitor$8(), hoistedIdentifiers);
-}
-let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
-  transformInstruction(instruction, state) {
-    this.visitInstruction(instruction, state);
-    if (
-      instruction.value.kind === 'DeclareContext' &&
-      instruction.value.lvalue.kind === 'HoistedConst'
-    ) {
-      state.set(
-        instruction.value.lvalue.place.identifier.declarationId,
-        InstructionKind.Const
-      );
-      return {kind: 'remove'};
-    }
-    if (
-      instruction.value.kind === 'DeclareContext' &&
-      instruction.value.lvalue.kind === 'HoistedLet'
-    ) {
-      state.set(
-        instruction.value.lvalue.place.identifier.declarationId,
-        InstructionKind.Let
-      );
-      return {kind: 'remove'};
-    }
-    if (
-      instruction.value.kind === 'DeclareContext' &&
-      instruction.value.lvalue.kind === 'HoistedFunction'
-    ) {
-      state.set(
-        instruction.value.lvalue.place.identifier.declarationId,
-        InstructionKind.Function
-      );
-      return {kind: 'remove'};
-    }
-    if (
-      instruction.value.kind === 'StoreContext' &&
-      state.has(instruction.value.lvalue.place.identifier.declarationId)
-    ) {
-      const kind = state.get(
-        instruction.value.lvalue.place.identifier.declarationId
-      );
-      return {
-        kind: 'replace',
-        value: {
-          kind: 'instruction',
-          instruction: Object.assign(Object.assign({}, instruction), {
-            value: Object.assign(Object.assign({}, instruction.value), {
-              lvalue: Object.assign(
-                Object.assign({}, instruction.value.lvalue),
-                {kind: kind}
-              ),
-              type: null,
-              kind: 'StoreLocal',
-            }),
-          }),
-        },
-      };
-    }
-    return {kind: 'keep'};
+    return {kind: 'keep'};
   }
 };
 function inferOperandEffect(state, place) {
@@ -156656,203 +155136,12 @@ function validateNoJSXInTryStatement(fn) {
     throw errors;
   }
 }
-function collectOptionalChainSidemap(fn) {
-  const context = {
-    blocks: fn.body.blocks,
-    seenOptionals: new Set(),
-    processedInstrsInOptional: new Set(),
-    temporariesReadInOptional: new Map(),
-    hoistableObjects: new Map(),
-  };
-  for (const [_, block] of fn.body.blocks) {
-    if (
-      block.terminal.kind === 'optional' &&
-      !context.seenOptionals.has(block.id)
-    ) {
-      traverseOptionalBlock(block, context, null);
-    }
-  }
-  return {
-    temporariesReadInOptional: context.temporariesReadInOptional,
-    processedInstrsInOptional: context.processedInstrsInOptional,
-    hoistableObjects: context.hoistableObjects,
-  };
-}
-function matchOptionalTestBlock(terminal, blocks) {
-  const consequentBlock = assertNonNull(blocks.get(terminal.consequent));
-  if (
-    consequentBlock.instructions.length === 2 &&
-    consequentBlock.instructions[0].value.kind === 'PropertyLoad' &&
-    consequentBlock.instructions[1].value.kind === 'StoreLocal'
-  ) {
-    const propertyLoad = consequentBlock.instructions[0];
-    const storeLocal = consequentBlock.instructions[1].value;
-    const storeLocalInstrId = consequentBlock.instructions[1].id;
-    CompilerError.invariant(
-      propertyLoad.value.object.identifier.id === terminal.test.identifier.id,
-      {
-        reason:
-          '[OptionalChainDeps] Inconsistent optional chaining property load',
-        description: `Test=${printIdentifier(terminal.test.identifier)} PropertyLoad base=${printIdentifier(propertyLoad.value.object.identifier)}`,
-        loc: propertyLoad.loc,
-      }
-    );
-    CompilerError.invariant(
-      storeLocal.value.identifier.id === propertyLoad.lvalue.identifier.id,
-      {
-        reason: '[OptionalChainDeps] Unexpected storeLocal',
-        loc: propertyLoad.loc,
-      }
-    );
-    if (
-      consequentBlock.terminal.kind !== 'goto' ||
-      consequentBlock.terminal.variant !== GotoVariant.Break
-    ) {
-      return null;
-    }
-    const alternate = assertNonNull(blocks.get(terminal.alternate));
-    CompilerError.invariant(
-      alternate.instructions.length === 2 &&
-        alternate.instructions[0].value.kind === 'Primitive' &&
-        alternate.instructions[1].value.kind === 'StoreLocal',
-      {reason: 'Unexpected alternate structure', loc: terminal.loc}
-    );
-    return {
-      consequentId: storeLocal.lvalue.place.identifier.id,
-      property: propertyLoad.value.property,
-      propertyId: propertyLoad.lvalue.identifier.id,
-      storeLocalInstrId: storeLocalInstrId,
-      consequentGoto: consequentBlock.terminal.block,
-    };
-  }
-  return null;
-}
-function traverseOptionalBlock(optional, context, outerAlternate) {
-  context.seenOptionals.add(optional.id);
-  const maybeTest = context.blocks.get(optional.terminal.test);
-  let test;
-  let baseObject;
-  if (maybeTest.terminal.kind === 'branch') {
-    CompilerError.invariant(optional.terminal.optional, {
-      reason: '[OptionalChainDeps] Expect base case to be always optional',
-      loc: optional.terminal.loc,
-    });
-    if (
-      maybeTest.instructions.length === 0 ||
-      maybeTest.instructions[0].value.kind !== 'LoadLocal'
-    ) {
-      return null;
-    }
-    const path = [];
-    for (let i = 1; i < maybeTest.instructions.length; i++) {
-      const instrVal = maybeTest.instructions[i].value;
-      const prevInstr = maybeTest.instructions[i - 1];
-      if (
-        instrVal.kind === 'PropertyLoad' &&
-        instrVal.object.identifier.id === prevInstr.lvalue.identifier.id
-      ) {
-        path.push({property: instrVal.property, optional: false});
-      } else {
-        return null;
-      }
-    }
-    CompilerError.invariant(
-      maybeTest.terminal.test.identifier.id ===
-        maybeTest.instructions.at(-1).lvalue.identifier.id,
-      {
-        reason: '[OptionalChainDeps] Unexpected test expression',
-        loc: maybeTest.terminal.loc,
-      }
-    );
-    baseObject = {
-      identifier: maybeTest.instructions[0].value.place.identifier,
-      path: path,
-    };
-    test = maybeTest.terminal;
-  } else if (maybeTest.terminal.kind === 'optional') {
-    const testBlock = context.blocks.get(maybeTest.terminal.fallthrough);
-    if (testBlock.terminal.kind !== 'branch') {
-      CompilerError.throwTodo({
-        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for optional fallthrough block`,
-        loc: maybeTest.terminal.loc,
-      });
-    }
-    const innerOptional = traverseOptionalBlock(
-      maybeTest,
-      context,
-      testBlock.terminal.alternate
-    );
-    if (innerOptional == null) {
-      return null;
-    }
-    if (testBlock.terminal.test.identifier.id !== innerOptional) {
-      return null;
-    }
-    if (!optional.terminal.optional) {
-      context.hoistableObjects.set(
-        optional.id,
-        assertNonNull(context.temporariesReadInOptional.get(innerOptional))
-      );
-    }
-    baseObject = assertNonNull(
-      context.temporariesReadInOptional.get(innerOptional)
-    );
-    test = testBlock.terminal;
-  } else {
-    return null;
-  }
-  if (test.alternate === outerAlternate) {
-    CompilerError.invariant(optional.instructions.length === 0, {
-      reason:
-        '[OptionalChainDeps] Unexpected instructions an inner optional block. ' +
-        'This indicates that the compiler may be incorrectly concatenating two unrelated optional chains',
-      loc: optional.terminal.loc,
-    });
-  }
-  const matchConsequentResult = matchOptionalTestBlock(test, context.blocks);
-  if (!matchConsequentResult) {
-    return null;
-  }
-  CompilerError.invariant(
-    matchConsequentResult.consequentGoto === optional.terminal.fallthrough,
-    {
-      reason: '[OptionalChainDeps] Unexpected optional goto-fallthrough',
-      description: `${matchConsequentResult.consequentGoto} != ${optional.terminal.fallthrough}`,
-      loc: optional.terminal.loc,
-    }
-  );
-  const load = {
-    identifier: baseObject.identifier,
-    path: [
-      ...baseObject.path,
-      {
-        property: matchConsequentResult.property,
-        optional: optional.terminal.optional,
-      },
-    ],
-  };
-  context.processedInstrsInOptional.add(
-    matchConsequentResult.storeLocalInstrId
-  );
-  context.processedInstrsInOptional.add(test.id);
-  context.temporariesReadInOptional.set(
-    matchConsequentResult.consequentId,
-    load
-  );
-  context.temporariesReadInOptional.set(matchConsequentResult.propertyId, load);
-  return matchConsequentResult.consequentId;
-}
 function collectHoistablePropertyLoads(
   fn,
   temporaries,
-  hoistableFromOptionals,
-  nestedFnImmutableContext
+  hoistableFromOptionals
 ) {
   const registry = new PropertyPathRegistry();
-  const functionExpressionLoads = collectFunctionExpressionFakeLoads(fn);
-  const actuallyEvaluatedTemporaries = new Map(
-    [...temporaries].filter(([id]) => !functionExpressionLoads.has(id))
-  );
   const knownImmutableIdentifiers = new Set();
   if (fn.fnType === 'Component' || fn.fnType === 'Hook') {
     for (const p of fn.params) {
@@ -156861,14 +155150,26 @@ function collectHoistablePropertyLoads(
       }
     }
   }
-  const nodes = collectNonNullsInBlocks(fn, {
-    temporaries: actuallyEvaluatedTemporaries,
+  return collectHoistablePropertyLoadsImpl(fn, {
+    temporaries: temporaries,
     knownImmutableIdentifiers: knownImmutableIdentifiers,
     hoistableFromOptionals: hoistableFromOptionals,
     registry: registry,
-    nestedFnImmutableContext: nestedFnImmutableContext,
+    nestedFnImmutableContext: null,
   });
-  propagateNonNull(fn, nodes, registry);
+}
+function collectHoistablePropertyLoadsImpl(fn, context) {
+  const functionExpressionLoads = collectFunctionExpressionFakeLoads(fn);
+  const actuallyEvaluatedTemporaries = new Map(
+    [...context.temporaries].filter(([id]) => !functionExpressionLoads.has(id))
+  );
+  const nodes = collectNonNullsInBlocks(
+    fn,
+    Object.assign(Object.assign({}, context), {
+      temporaries: actuallyEvaluatedTemporaries,
+    })
+  );
+  propagateNonNull(fn, nodes, context.registry);
   return nodes;
 }
 function keyByScopeId(fn, source) {
@@ -157005,28 +155306,25 @@ function collectNonNullsInBlocks(fn, context) {
         assumedNonNullObjects.add(maybeNonNull);
       }
       if (
-        instr.value.kind === 'FunctionExpression' &&
+        (instr.value.kind === 'FunctionExpression' ||
+          instr.value.kind === 'ObjectMethod') &&
         !fn.env.config.enableTreatFunctionDepsAsConditional
       ) {
         const innerFn = instr.value.loweredFunc;
-        const innerTemporaries = collectTemporariesSidemap(
-          innerFn.func,
-          new Set()
-        );
-        const innerOptionals = collectOptionalChainSidemap(innerFn.func);
-        const innerHoistableMap = collectHoistablePropertyLoads(
+        const innerHoistableMap = collectHoistablePropertyLoadsImpl(
           innerFn.func,
-          innerTemporaries,
-          innerOptionals.hoistableObjects,
-          (_a = context.nestedFnImmutableContext) !== null && _a !== void 0
-            ? _a
-            : new Set(
-                innerFn.func.context
-                  .filter(place =>
-                    isImmutableAtInstr(place.identifier, instr.id, context)
-                  )
-                  .map(place => place.identifier.id)
-              )
+          Object.assign(Object.assign({}, context), {
+            nestedFnImmutableContext:
+              (_a = context.nestedFnImmutableContext) !== null && _a !== void 0
+                ? _a
+                : new Set(
+                    innerFn.func.context
+                      .filter(place =>
+                        isImmutableAtInstr(place.identifier, instr.id, context)
+                      )
+                      .map(place => place.identifier.id)
+                  ),
+          })
         );
         const innerHoistables = assertNonNull(
           innerHoistableMap.get(innerFn.func.body.entry)
@@ -157175,7 +155473,10 @@ function collectFunctionExpressionFakeLoads(fn) {
   const functionExpressionReferences = new Set();
   for (const [_, block] of fn.body.blocks) {
     for (const {lvalue: lvalue, value: value} of block.instructions) {
-      if (value.kind === 'FunctionExpression') {
+      if (
+        value.kind === 'FunctionExpression' ||
+        value.kind === 'ObjectMethod'
+      ) {
         for (const reference of value.loweredFunc.dependencies) {
           let curr = reference.identifier.id;
           while (curr != null) {
@@ -157188,8 +155489,76 @@ function collectFunctionExpressionFakeLoads(fn) {
       }
     }
   }
-  return functionExpressionReferences;
+  return functionExpressionReferences;
+}
+var _Node_value, _Node_next;
+function empty() {
+  return EMPTY;
+}
+class Node {
+  constructor(value, next = EMPTY) {
+    _Node_value.set(this, void 0);
+    _Node_next.set(this, void 0);
+    __classPrivateFieldSet(this, _Node_value, value, 'f');
+    __classPrivateFieldSet(this, _Node_next, next, 'f');
+  }
+  push(value) {
+    return new Node(value, this);
+  }
+  pop() {
+    return __classPrivateFieldGet(this, _Node_next, 'f');
+  }
+  find(fn) {
+    return fn(__classPrivateFieldGet(this, _Node_value, 'f'))
+      ? true
+      : __classPrivateFieldGet(this, _Node_next, 'f').find(fn);
+  }
+  contains(value) {
+    return (
+      value === __classPrivateFieldGet(this, _Node_value, 'f') ||
+      (__classPrivateFieldGet(this, _Node_next, 'f') !== null &&
+        __classPrivateFieldGet(this, _Node_next, 'f').contains(value))
+    );
+  }
+  each(fn) {
+    fn(__classPrivateFieldGet(this, _Node_value, 'f'));
+    __classPrivateFieldGet(this, _Node_next, 'f').each(fn);
+  }
+  get value() {
+    return __classPrivateFieldGet(this, _Node_value, 'f');
+  }
+  print(fn) {
+    return (
+      fn(__classPrivateFieldGet(this, _Node_value, 'f')) +
+      __classPrivateFieldGet(this, _Node_next, 'f').print(fn)
+    );
+  }
+}
+(_Node_value = new WeakMap()), (_Node_next = new WeakMap());
+class Empty {
+  push(value) {
+    return new Node(value, this);
+  }
+  pop() {
+    return this;
+  }
+  find(_fn) {
+    return false;
+  }
+  contains(_value) {
+    return false;
+  }
+  each(_fn) {
+    return;
+  }
+  get value() {
+    return null;
+  }
+  print(_) {
+    return '';
+  }
 }
+const EMPTY = new Empty();
 var _a,
   _ReactiveScopeDependencyTreeHIR_hoistableObjects,
   _ReactiveScopeDependencyTreeHIR_deps,
@@ -157449,6 +155818,208 @@ function makeOrMergeProperty(node, property, accessType) {
   }
   return child;
 }
+function collectOptionalChainSidemap(fn) {
+  const context = {
+    currFn: fn,
+    blocks: fn.body.blocks,
+    seenOptionals: new Set(),
+    processedInstrsInOptional: new Set(),
+    temporariesReadInOptional: new Map(),
+    hoistableObjects: new Map(),
+  };
+  traverseFunction(fn, context);
+  return {
+    temporariesReadInOptional: context.temporariesReadInOptional,
+    processedInstrsInOptional: context.processedInstrsInOptional,
+    hoistableObjects: context.hoistableObjects,
+  };
+}
+function traverseFunction(fn, context) {
+  for (const [_, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      if (
+        instr.value.kind === 'FunctionExpression' ||
+        instr.value.kind === 'ObjectMethod'
+      ) {
+        traverseFunction(
+          instr.value.loweredFunc.func,
+          Object.assign(Object.assign({}, context), {
+            currFn: instr.value.loweredFunc.func,
+            blocks: instr.value.loweredFunc.func.body.blocks,
+          })
+        );
+      }
+    }
+    if (
+      block.terminal.kind === 'optional' &&
+      !context.seenOptionals.has(block.id)
+    ) {
+      traverseOptionalBlock(block, context, null);
+    }
+  }
+}
+function matchOptionalTestBlock(terminal, blocks) {
+  const consequentBlock = assertNonNull(blocks.get(terminal.consequent));
+  if (
+    consequentBlock.instructions.length === 2 &&
+    consequentBlock.instructions[0].value.kind === 'PropertyLoad' &&
+    consequentBlock.instructions[1].value.kind === 'StoreLocal'
+  ) {
+    const propertyLoad = consequentBlock.instructions[0];
+    const storeLocal = consequentBlock.instructions[1].value;
+    const storeLocalInstr = consequentBlock.instructions[1];
+    CompilerError.invariant(
+      propertyLoad.value.object.identifier.id === terminal.test.identifier.id,
+      {
+        reason:
+          '[OptionalChainDeps] Inconsistent optional chaining property load',
+        description: `Test=${printIdentifier(terminal.test.identifier)} PropertyLoad base=${printIdentifier(propertyLoad.value.object.identifier)}`,
+        loc: propertyLoad.loc,
+      }
+    );
+    CompilerError.invariant(
+      storeLocal.value.identifier.id === propertyLoad.lvalue.identifier.id,
+      {
+        reason: '[OptionalChainDeps] Unexpected storeLocal',
+        loc: propertyLoad.loc,
+      }
+    );
+    if (
+      consequentBlock.terminal.kind !== 'goto' ||
+      consequentBlock.terminal.variant !== GotoVariant.Break
+    ) {
+      return null;
+    }
+    const alternate = assertNonNull(blocks.get(terminal.alternate));
+    CompilerError.invariant(
+      alternate.instructions.length === 2 &&
+        alternate.instructions[0].value.kind === 'Primitive' &&
+        alternate.instructions[1].value.kind === 'StoreLocal',
+      {reason: 'Unexpected alternate structure', loc: terminal.loc}
+    );
+    return {
+      consequentId: storeLocal.lvalue.place.identifier.id,
+      property: propertyLoad.value.property,
+      propertyId: propertyLoad.lvalue.identifier.id,
+      storeLocalInstr: storeLocalInstr,
+      consequentGoto: consequentBlock.terminal.block,
+    };
+  }
+  return null;
+}
+function traverseOptionalBlock(optional, context, outerAlternate) {
+  context.seenOptionals.add(optional.id);
+  const maybeTest = context.blocks.get(optional.terminal.test);
+  let test;
+  let baseObject;
+  if (maybeTest.terminal.kind === 'branch') {
+    CompilerError.invariant(optional.terminal.optional, {
+      reason: '[OptionalChainDeps] Expect base case to be always optional',
+      loc: optional.terminal.loc,
+    });
+    if (
+      maybeTest.instructions.length === 0 ||
+      maybeTest.instructions[0].value.kind !== 'LoadLocal'
+    ) {
+      return null;
+    }
+    const path = [];
+    for (let i = 1; i < maybeTest.instructions.length; i++) {
+      const instrVal = maybeTest.instructions[i].value;
+      const prevInstr = maybeTest.instructions[i - 1];
+      if (
+        instrVal.kind === 'PropertyLoad' &&
+        instrVal.object.identifier.id === prevInstr.lvalue.identifier.id
+      ) {
+        path.push({property: instrVal.property, optional: false});
+      } else {
+        return null;
+      }
+    }
+    CompilerError.invariant(
+      maybeTest.terminal.test.identifier.id ===
+        maybeTest.instructions.at(-1).lvalue.identifier.id,
+      {
+        reason: '[OptionalChainDeps] Unexpected test expression',
+        loc: maybeTest.terminal.loc,
+      }
+    );
+    baseObject = {
+      identifier: maybeTest.instructions[0].value.place.identifier,
+      path: path,
+    };
+    test = maybeTest.terminal;
+  } else if (maybeTest.terminal.kind === 'optional') {
+    const testBlock = context.blocks.get(maybeTest.terminal.fallthrough);
+    if (testBlock.terminal.kind !== 'branch') {
+      CompilerError.throwTodo({
+        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for optional fallthrough block`,
+        loc: maybeTest.terminal.loc,
+      });
+    }
+    const innerOptional = traverseOptionalBlock(
+      maybeTest,
+      context,
+      testBlock.terminal.alternate
+    );
+    if (innerOptional == null) {
+      return null;
+    }
+    if (testBlock.terminal.test.identifier.id !== innerOptional) {
+      return null;
+    }
+    if (!optional.terminal.optional) {
+      context.hoistableObjects.set(
+        optional.id,
+        assertNonNull(context.temporariesReadInOptional.get(innerOptional))
+      );
+    }
+    baseObject = assertNonNull(
+      context.temporariesReadInOptional.get(innerOptional)
+    );
+    test = testBlock.terminal;
+  } else {
+    return null;
+  }
+  if (test.alternate === outerAlternate) {
+    CompilerError.invariant(optional.instructions.length === 0, {
+      reason:
+        '[OptionalChainDeps] Unexpected instructions an inner optional block. ' +
+        'This indicates that the compiler may be incorrectly concatenating two unrelated optional chains',
+      loc: optional.terminal.loc,
+    });
+  }
+  const matchConsequentResult = matchOptionalTestBlock(test, context.blocks);
+  if (!matchConsequentResult) {
+    return null;
+  }
+  CompilerError.invariant(
+    matchConsequentResult.consequentGoto === optional.terminal.fallthrough,
+    {
+      reason: '[OptionalChainDeps] Unexpected optional goto-fallthrough',
+      description: `${matchConsequentResult.consequentGoto} != ${optional.terminal.fallthrough}`,
+      loc: optional.terminal.loc,
+    }
+  );
+  const load = {
+    identifier: baseObject.identifier,
+    path: [
+      ...baseObject.path,
+      {
+        property: matchConsequentResult.property,
+        optional: optional.terminal.optional,
+      },
+    ],
+  };
+  context.processedInstrsInOptional.add(matchConsequentResult.storeLocalInstr);
+  context.processedInstrsInOptional.add(test);
+  context.temporariesReadInOptional.set(
+    matchConsequentResult.consequentId,
+    load
+  );
+  context.temporariesReadInOptional.set(matchConsequentResult.propertyId, load);
+  return matchConsequentResult.consequentId;
+}
 var _Context_instances,
   _Context_declarations,
   _Context_reassignments,
@@ -157469,7 +156040,7 @@ function propagateScopeDependenciesHIR(fn) {
   } = collectOptionalChainSidemap(fn);
   const hoistablePropertyLoads = keyByScopeId(
     fn,
-    collectHoistablePropertyLoads(fn, temporaries, hoistableObjects, null)
+    collectHoistablePropertyLoads(fn, temporaries, hoistableObjects)
   );
   const scopeDeps = collectDependencies(
     fn,
@@ -157561,6 +156132,20 @@ function findTemporariesUsedOutsideDeclaringScope(fn) {
 }
 function collectTemporariesSidemap(fn, usedOutsideDeclaringScope) {
   const temporaries = new Map();
+  collectTemporariesSidemapImpl(
+    fn,
+    usedOutsideDeclaringScope,
+    temporaries,
+    false
+  );
+  return temporaries;
+}
+function collectTemporariesSidemapImpl(
+  fn,
+  usedOutsideDeclaringScope,
+  temporaries,
+  isInnerFn
+) {
   for (const [_, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
       const {value: value, lvalue: lvalue} = instr;
@@ -157568,27 +156153,45 @@ function collectTemporariesSidemap(fn, usedOutsideDeclaringScope) {
         lvalue.identifier.declarationId
       );
       if (value.kind === 'PropertyLoad' && !usedOutside) {
-        const property = getProperty(
-          value.object,
-          value.property,
-          false,
-          temporaries
-        );
-        temporaries.set(lvalue.identifier.id, property);
+        if (!isInnerFn || temporaries.has(value.object.identifier.id)) {
+          const property = getProperty(
+            value.object,
+            value.property,
+            false,
+            temporaries
+          );
+          temporaries.set(lvalue.identifier.id, property);
+        }
       } else if (
         value.kind === 'LoadLocal' &&
         lvalue.identifier.name == null &&
         value.place.identifier.name !== null &&
         !usedOutside
       ) {
-        temporaries.set(lvalue.identifier.id, {
-          identifier: value.place.identifier,
-          path: [],
-        });
+        if (
+          !isInnerFn ||
+          fn.context.some(
+            context => context.identifier.id === value.place.identifier.id
+          )
+        ) {
+          temporaries.set(lvalue.identifier.id, {
+            identifier: value.place.identifier,
+            path: [],
+          });
+        }
+      } else if (
+        value.kind === 'FunctionExpression' ||
+        value.kind === 'ObjectMethod'
+      ) {
+        collectTemporariesSidemapImpl(
+          value.loweredFunc.func,
+          usedOutsideDeclaringScope,
+          temporaries,
+          true
+        );
       }
     }
   }
-  return temporaries;
 }
 function getProperty(object, propertyName, optional, temporaries) {
   const resolvedDependency = temporaries.get(object.identifier.id);
@@ -157619,6 +156222,7 @@ class Context {
     this.deps = new Map();
     _Context_temporaries.set(this, void 0);
     _Context_temporariesUsedOutsideScope.set(this, void 0);
+    this.inInnerFn = false;
     __classPrivateFieldSet(
       this,
       _Context_temporariesUsedOutsideScope,
@@ -157694,6 +156298,7 @@ class Context {
     ).has(place.identifier.declarationId);
   }
   declare(identifier, decl) {
+    if (this.inInnerFn) return;
     if (
       !__classPrivateFieldGet(this, _Context_declarations, 'f').has(
         identifier.declarationId
@@ -157939,11 +156544,11 @@ function collectDependencies(
       }
     }
     for (const instr of block.instructions) {
-      if (!processedInstrsInOptional.has(instr.id)) {
+      if (!processedInstrsInOptional.has(instr)) {
         handleInstruction(instr, context);
       }
     }
-    if (!processedInstrsInOptional.has(block.terminal.id)) {
+    if (!processedInstrsInOptional.has(block.terminal)) {
       for (const place of eachTerminalOperand(block.terminal)) {
         context.visitOperand(place);
       }
@@ -158416,10 +157021,8 @@ function* runWithEnvironment(func, env) {
   yield log({kind: 'hir', name: 'FlattenScopesWithHooksOrUseHIR', value: hir});
   assertTerminalSuccessorsExist(hir);
   assertTerminalPredsExist(hir);
-  if (env.config.enablePropagateDepsInHIR) {
-    propagateScopeDependenciesHIR(hir);
-    yield log({kind: 'hir', name: 'PropagateScopeDependenciesHIR', value: hir});
-  }
+  propagateScopeDependenciesHIR(hir);
+  yield log({kind: 'hir', name: 'PropagateScopeDependenciesHIR', value: hir});
   if (env.config.inlineJsxTransform) {
     inlineJsxTransform(hir, env.config.inlineJsxTransform);
     yield log({kind: 'hir', name: 'inlineJsxTransform', value: hir});
@@ -158438,14 +157041,6 @@ function* runWithEnvironment(func, env) {
     value: reactiveFunction,
   });
   assertScopeInstructionsWithinScopes(reactiveFunction);
-  if (!env.config.enablePropagateDepsInHIR) {
-    propagateScopeDependencies(reactiveFunction);
-    yield log({
-      kind: 'reactive',
-      name: 'PropagateScopeDependencies',
-      value: reactiveFunction,
-    });
-  }
   pruneNonEscapingScopes(reactiveFunction);
   yield log({
     kind: 'reactive',
@@ -159676,7 +158271,7 @@ exports.OPT_OUT_DIRECTIVES = OPT_OUT_DIRECTIVES;
 exports.compile = compileFn;
 exports.compileProgram = compileProgram;
 exports.default = BabelPluginReactCompiler;
-exports.parseConfigPragma = parseConfigPragma;
+exports.parseConfigPragmaForTests = parseConfigPragmaForTests;
 exports.parsePluginOptions = parsePluginOptions;
 exports.printHIR = printHIR;
 exports.printReactiveFunction = printReactiveFunction;