@tanstack/router-plugin 1.159.10 → 1.159.12

package/dist/cjs/core/code-splitter/compilers.cjs

@@ -105,6 +105,10 @@ function removeSplitSearchParamFromFilename(filename) {
   const [bareFilename] = filename.split("?");
   return bareFilename;
 }
+function addSharedSearchParamToFilename(filename) {
+  const [bareFilename] = filename.split("?");
+  return `${bareFilename}?${constants.tsrShared}=1`;
+}
 const splittableCreateRouteFns = ["createFileRoute"];
 const unsplittableCreateRouteFns = [
   "createRootRoute",
@@ -114,6 +118,304 @@ const allCreateRouteFns = [
   ...splittableCreateRouteFns,
   ...unsplittableCreateRouteFns
 ];
+function collectIdentifiersFromNode(node) {
+  const ids = /* @__PURE__ */ new Set();
+  (function walk(n, parent, grandparent, parentKey) {
+    if (!n) return;
+    if (t__namespace.isIdentifier(n)) {
+      if (!parent || t__namespace.isReferenced(n, parent, grandparent)) {
+        ids.add(n.name);
+      }
+      return;
+    }
+    if (t__namespace.isJSXIdentifier(n)) {
+      if (parent && t__namespace.isJSXAttribute(parent) && parentKey === "name") {
+        return;
+      }
+      if (parent && t__namespace.isJSXMemberExpression(parent) && parentKey === "property") {
+        return;
+      }
+      const first = n.name[0];
+      if (first && first === first.toLowerCase()) {
+        return;
+      }
+      ids.add(n.name);
+      return;
+    }
+    for (const key of t__namespace.VISITOR_KEYS[n.type] || []) {
+      const child = n[key];
+      if (Array.isArray(child)) {
+        for (const c of child) {
+          if (c && typeof c.type === "string") {
+            walk(c, n, parent, key);
+          }
+        }
+      } else if (child && typeof child.type === "string") {
+        walk(child, n, parent, key);
+      }
+    }
+  })(node);
+  return ids;
+}
+function buildDeclarationMap(ast) {
+  const map = /* @__PURE__ */ new Map();
+  for (const stmt of ast.program.body) {
+    const decl = t__namespace.isExportNamedDeclaration(stmt) && stmt.declaration ? stmt.declaration : stmt;
+    if (t__namespace.isVariableDeclaration(decl)) {
+      for (const declarator of decl.declarations) {
+        for (const name of collectIdentifiersFromPattern(declarator.id)) {
+          map.set(name, declarator);
+        }
+      }
+    } else if (t__namespace.isFunctionDeclaration(decl) && decl.id) {
+      map.set(decl.id.name, decl);
+    } else if (t__namespace.isClassDeclaration(decl) && decl.id) {
+      map.set(decl.id.name, decl);
+    }
+  }
+  return map;
+}
+function buildDependencyGraph(declMap, localBindings) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const [name, declNode] of declMap) {
+    if (!localBindings.has(name)) continue;
+    const allIds = collectIdentifiersFromNode(declNode);
+    const deps = /* @__PURE__ */ new Set();
+    for (const id of allIds) {
+      if (id !== name && localBindings.has(id)) deps.add(id);
+    }
+    graph.set(name, deps);
+  }
+  return graph;
+}
+function computeSharedBindings(opts) {
+  const ast = routerUtils.parseAst(opts);
+  const localModuleLevelBindings = /* @__PURE__ */ new Set();
+  for (const node of ast.program.body) {
+    collectLocalBindingsFromStatement(node, localModuleLevelBindings);
+  }
+  localModuleLevelBindings.delete("Route");
+  if (localModuleLevelBindings.size === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  function findIndexForSplitNode(str) {
+    return opts.codeSplitGroupings.findIndex(
+      (group) => group.includes(str)
+    );
+  }
+  let routeOptions;
+  babel.traverse(ast, {
+    CallExpression(path) {
+      if (!t__namespace.isIdentifier(path.node.callee)) return;
+      if (!splittableCreateRouteFns.includes(path.node.callee.name)) return;
+      if (t__namespace.isCallExpression(path.parentPath.node)) {
+        const opts2 = resolveIdentifier(path, path.parentPath.node.arguments[0]);
+        if (t__namespace.isObjectExpression(opts2)) routeOptions = opts2;
+      } else if (t__namespace.isVariableDeclarator(path.parentPath.node)) {
+        const caller = resolveIdentifier(path, path.parentPath.node.init);
+        if (t__namespace.isCallExpression(caller)) {
+          const opts2 = resolveIdentifier(path, caller.arguments[0]);
+          if (t__namespace.isObjectExpression(opts2)) routeOptions = opts2;
+        }
+      }
+    }
+  });
+  if (!routeOptions) return /* @__PURE__ */ new Set();
+  const splitGroupsPresent = /* @__PURE__ */ new Set();
+  let hasNonSplit = false;
+  for (const prop of routeOptions.properties) {
+    if (!t__namespace.isObjectProperty(prop) || !t__namespace.isIdentifier(prop.key)) continue;
+    if (prop.key.name === "codeSplitGroupings") continue;
+    if (t__namespace.isIdentifier(prop.value) && prop.value.name === "undefined") continue;
+    const groupIndex = findIndexForSplitNode(prop.key.name);
+    if (groupIndex === -1) {
+      hasNonSplit = true;
+    } else {
+      splitGroupsPresent.add(groupIndex);
+    }
+  }
+  if (!hasNonSplit && splitGroupsPresent.size < 2) return /* @__PURE__ */ new Set();
+  const declMap = buildDeclarationMap(ast);
+  const depGraph = buildDependencyGraph(declMap, localModuleLevelBindings);
+  const allLocalBindings = new Set(localModuleLevelBindings);
+  allLocalBindings.add("Route");
+  const fullDepGraph = buildDependencyGraph(declMap, allLocalBindings);
+  const refsByGroup = /* @__PURE__ */ new Map();
+  for (const prop of routeOptions.properties) {
+    if (!t__namespace.isObjectProperty(prop) || !t__namespace.isIdentifier(prop.key)) continue;
+    const key = prop.key.name;
+    if (key === "codeSplitGroupings") continue;
+    const groupIndex = findIndexForSplitNode(key);
+    const directRefs = collectModuleLevelRefsFromNode(
+      prop.value,
+      localModuleLevelBindings
+    );
+    const allRefs = new Set(directRefs);
+    expandTransitively(allRefs, depGraph);
+    for (const ref of allRefs) {
+      let groups = refsByGroup.get(ref);
+      if (!groups) {
+        groups = /* @__PURE__ */ new Set();
+        refsByGroup.set(ref, groups);
+      }
+      groups.add(groupIndex);
+    }
+  }
+  const shared = /* @__PURE__ */ new Set();
+  for (const [name, groups] of refsByGroup) {
+    if (groups.size >= 2) shared.add(name);
+  }
+  expandSharedDestructuredDeclarators(ast, refsByGroup, shared);
+  if (shared.size === 0) return shared;
+  expandDestructuredDeclarations(ast, shared);
+  removeBindingsDependingOnRoute(shared, fullDepGraph);
+  return shared;
+}
+function expandSharedDestructuredDeclarators(ast, refsByGroup, shared) {
+  for (const stmt of ast.program.body) {
+    const decl = t__namespace.isExportNamedDeclaration(stmt) && stmt.declaration ? stmt.declaration : stmt;
+    if (!t__namespace.isVariableDeclaration(decl)) continue;
+    for (const declarator of decl.declarations) {
+      if (!t__namespace.isObjectPattern(declarator.id) && !t__namespace.isArrayPattern(declarator.id))
+        continue;
+      const names = collectIdentifiersFromPattern(declarator.id);
+      const usedGroups = /* @__PURE__ */ new Set();
+      for (const name of names) {
+        const groups = refsByGroup.get(name);
+        if (!groups) continue;
+        for (const g of groups) usedGroups.add(g);
+      }
+      if (usedGroups.size >= 2) {
+        for (const name of names) {
+          shared.add(name);
+        }
+      }
+    }
+  }
+}
+function collectLocalBindingsFromStatement(node, bindings) {
+  const decl = t__namespace.isExportNamedDeclaration(node) && node.declaration ? node.declaration : node;
+  if (t__namespace.isVariableDeclaration(decl)) {
+    for (const declarator of decl.declarations) {
+      for (const name of collectIdentifiersFromPattern(declarator.id)) {
+        bindings.add(name);
+      }
+    }
+  } else if (t__namespace.isFunctionDeclaration(decl) && decl.id) {
+    bindings.add(decl.id.name);
+  } else if (t__namespace.isClassDeclaration(decl) && decl.id) {
+    bindings.add(decl.id.name);
+  }
+}
+function collectModuleLevelRefsFromNode(node, localModuleLevelBindings) {
+  const allIds = collectIdentifiersFromNode(node);
+  const refs = /* @__PURE__ */ new Set();
+  for (const name of allIds) {
+    if (localModuleLevelBindings.has(name)) refs.add(name);
+  }
+  return refs;
+}
+function expandTransitively(shared, depGraph) {
+  const queue = [...shared];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const name = queue.pop();
+    if (visited.has(name)) continue;
+    visited.add(name);
+    const deps = depGraph.get(name);
+    if (!deps) continue;
+    for (const dep of deps) {
+      if (!shared.has(dep)) {
+        shared.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+}
+function removeBindingsDependingOnRoute(shared, depGraph) {
+  const reverseGraph = /* @__PURE__ */ new Map();
+  for (const [name, deps] of depGraph) {
+    for (const dep of deps) {
+      let parents = reverseGraph.get(dep);
+      if (!parents) {
+        parents = /* @__PURE__ */ new Set();
+        reverseGraph.set(dep, parents);
+      }
+      parents.add(name);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = ["Route"];
+  while (queue.length > 0) {
+    const cur = queue.pop();
+    if (visited.has(cur)) continue;
+    visited.add(cur);
+    const parents = reverseGraph.get(cur);
+    if (!parents) continue;
+    for (const parent of parents) {
+      if (!visited.has(parent)) queue.push(parent);
+    }
+  }
+  for (const name of [...shared]) {
+    if (visited.has(name)) {
+      shared.delete(name);
+    }
+  }
+}
+function expandDestructuredDeclarations(ast, shared) {
+  for (const stmt of ast.program.body) {
+    const decl = t__namespace.isExportNamedDeclaration(stmt) && stmt.declaration ? stmt.declaration : stmt;
+    if (!t__namespace.isVariableDeclaration(decl)) continue;
+    for (const declarator of decl.declarations) {
+      if (!t__namespace.isObjectPattern(declarator.id) && !t__namespace.isArrayPattern(declarator.id))
+        continue;
+      const names = collectIdentifiersFromPattern(declarator.id);
+      const hasShared = names.some((n) => shared.has(n));
+      if (hasShared) {
+        for (const n of names) {
+          shared.add(n);
+        }
+      }
+    }
+  }
+}
+function findExportedSharedBindings(ast, sharedBindings) {
+  const exported = /* @__PURE__ */ new Set();
+  for (const stmt of ast.program.body) {
+    if (!t__namespace.isExportNamedDeclaration(stmt) || !stmt.declaration) continue;
+    if (t__namespace.isVariableDeclaration(stmt.declaration)) {
+      for (const decl of stmt.declaration.declarations) {
+        for (const name of collectIdentifiersFromPattern(decl.id)) {
+          if (sharedBindings.has(name)) exported.add(name);
+        }
+      }
+    } else if (t__namespace.isFunctionDeclaration(stmt.declaration) && stmt.declaration.id) {
+      if (sharedBindings.has(stmt.declaration.id.name))
+        exported.add(stmt.declaration.id.name);
+    } else if (t__namespace.isClassDeclaration(stmt.declaration) && stmt.declaration.id) {
+      if (sharedBindings.has(stmt.declaration.id.name))
+        exported.add(stmt.declaration.id.name);
+    }
+  }
+  return exported;
+}
+function removeSharedDeclarations(ast, sharedBindings) {
+  ast.program.body = ast.program.body.filter((stmt) => {
+    const decl = t__namespace.isExportNamedDeclaration(stmt) && stmt.declaration ? stmt.declaration : stmt;
+    if (t__namespace.isVariableDeclaration(decl)) {
+      decl.declarations = decl.declarations.filter((declarator) => {
+        const names = collectIdentifiersFromPattern(declarator.id);
+        return !names.every((n) => sharedBindings.has(n));
+      });
+      if (decl.declarations.length === 0) return false;
+    } else if (t__namespace.isFunctionDeclaration(decl) && decl.id) {
+      if (sharedBindings.has(decl.id.name)) return false;
+    } else if (t__namespace.isClassDeclaration(decl) && decl.id) {
+      if (sharedBindings.has(decl.id.name)) return false;
+    }
+    return true;
+  });
+}
 function compileCodeSplitReferenceRoute(opts) {
   const ast = routerUtils.parseAst(opts);
   const refIdents = routerUtils.findReferencedIdentifiers(ast);
@@ -130,6 +432,7 @@ function compileCodeSplitReferenceRoute(opts) {
   let createRouteFn;
   let modified = false;
   let hmrAdded = false;
+  let sharedExportedNames;
   babel.traverse(ast, {
     Program: {
       enter(programPath) {
@@ -325,6 +628,44 @@ function compileCodeSplitReferenceRoute(opts) {
             }
           });
         }
+        if (opts.sharedBindings && opts.sharedBindings.size > 0) {
+          sharedExportedNames = findExportedSharedBindings(
+            ast,
+            opts.sharedBindings
+          );
+          removeSharedDeclarations(ast, opts.sharedBindings);
+          const sharedModuleUrl = addSharedSearchParamToFilename(opts.filename);
+          const sharedImportSpecifiers = [...opts.sharedBindings].map(
+            (name) => t__namespace.importSpecifier(t__namespace.identifier(name), t__namespace.identifier(name))
+          );
+          const [sharedImportPath] = programPath.unshiftContainer(
+            "body",
+            t__namespace.importDeclaration(
+              sharedImportSpecifiers,
+              t__namespace.stringLiteral(sharedModuleUrl)
+            )
+          );
+          sharedImportPath.traverse({
+            Identifier(identPath) {
+              if (identPath.parentPath.isImportSpecifier() && identPath.key === "local") {
+                refIdents.add(identPath);
+              }
+            }
+          });
+          if (sharedExportedNames.size > 0) {
+            const reExportSpecifiers = [...sharedExportedNames].map(
+              (name) => t__namespace.exportSpecifier(t__namespace.identifier(name), t__namespace.identifier(name))
+            );
+            programPath.pushContainer(
+              "body",
+              t__namespace.exportNamedDeclaration(
+                null,
+                reExportSpecifiers,
+                t__namespace.stringLiteral(sharedModuleUrl)
+              )
+            );
+          }
+        }
       }
     }
   });
@@ -354,6 +695,9 @@ function compileCodeSplitReferenceRoute(opts) {
 function compileCodeSplitVirtualRoute(opts) {
   const ast = routerUtils.parseAst(opts);
   const refIdents = routerUtils.findReferencedIdentifiers(ast);
+  if (opts.sharedBindings && opts.sharedBindings.size > 0) {
+    removeSharedDeclarations(ast, opts.sharedBindings);
+  }
   const intendedSplitNodes = new Set(opts.splitTargets);
   const knownExportedIdents = /* @__PURE__ */ new Set();
   babel.traverse(ast, {
@@ -430,6 +774,10 @@ function compileCodeSplitVirtualRoute(opts) {
           }
           let splitNode = splitKey.node;
           const splitMeta = { ...splitKey.meta, shouldRemoveNode: true };
+          let originalIdentName;
+          if (t__namespace.isIdentifier(splitNode)) {
+            originalIdentName = splitNode.name;
+          }
           while (t__namespace.isIdentifier(splitNode)) {
             const binding = programPath.scope.getBinding(splitNode.name);
             splitNode = binding?.path.node;
@@ -467,6 +815,11 @@ function compileCodeSplitVirtualRoute(opts) {
               if (t__namespace.isIdentifier(splitNode.id)) {
                 splitMeta.localExporterIdent = splitNode.id.name;
                 splitMeta.shouldRemoveNode = false;
+              } else if (t__namespace.isObjectPattern(splitNode.id)) {
+                if (originalIdentName) {
+                  splitMeta.localExporterIdent = originalIdentName;
+                }
+                splitMeta.shouldRemoveNode = false;
               } else {
                 throw new Error(
                   `Unexpected splitNode type ☝️: ${splitNode.type}`
@@ -552,13 +905,41 @@ function compileCodeSplitVirtualRoute(opts) {
           ExportNamedDeclaration(path) {
             if (path.node.declaration) {
               if (t__namespace.isVariableDeclaration(path.node.declaration)) {
+                const specifiers = path.node.declaration.declarations.flatMap(
+                  (decl) => {
+                    if (t__namespace.isIdentifier(decl.id)) {
+                      return [
+                        t__namespace.importSpecifier(
+                          t__namespace.identifier(decl.id.name),
+                          t__namespace.identifier(decl.id.name)
+                        )
+                      ];
+                    }
+                    if (t__namespace.isObjectPattern(decl.id)) {
+                      return collectIdentifiersFromPattern(decl.id).map(
+                        (name) => t__namespace.importSpecifier(
+                          t__namespace.identifier(name),
+                          t__namespace.identifier(name)
+                        )
+                      );
+                    }
+                    if (t__namespace.isArrayPattern(decl.id)) {
+                      return collectIdentifiersFromPattern(decl.id).map(
+                        (name) => t__namespace.importSpecifier(
+                          t__namespace.identifier(name),
+                          t__namespace.identifier(name)
+                        )
+                      );
+                    }
+                    return [];
+                  }
+                );
+                if (specifiers.length === 0) {
+                  path.remove();
+                  return;
+                }
                 const importDecl = t__namespace.importDeclaration(
-                  path.node.declaration.declarations.map(
-                    (decl) => t__namespace.importSpecifier(
-                      t__namespace.identifier(decl.id.name),
-                      t__namespace.identifier(decl.id.name)
-                    )
-                  ),
+                  specifiers,
                   t__namespace.stringLiteral(
                     removeSplitSearchParamFromFilename(opts.filename)
                   )
@@ -575,10 +956,121 @@ function compileCodeSplitVirtualRoute(opts) {
             }
           }
         });
+        if (opts.sharedBindings && opts.sharedBindings.size > 0) {
+          const sharedImportSpecifiers = [...opts.sharedBindings].map(
+            (name) => t__namespace.importSpecifier(t__namespace.identifier(name), t__namespace.identifier(name))
+          );
+          const sharedModuleUrl = addSharedSearchParamToFilename(
+            removeSplitSearchParamFromFilename(opts.filename)
+          );
+          const [sharedImportPath] = programPath.unshiftContainer(
+            "body",
+            t__namespace.importDeclaration(
+              sharedImportSpecifiers,
+              t__namespace.stringLiteral(sharedModuleUrl)
+            )
+          );
+          sharedImportPath.traverse({
+            Identifier(identPath) {
+              if (identPath.parentPath.isImportSpecifier() && identPath.key === "local") {
+                refIdents.add(identPath);
+              }
+            }
+          });
+        }
+      }
+    }
+  });
+  routerUtils.deadCodeElimination(ast, refIdents);
+  {
+    const locallyBound = /* @__PURE__ */ new Set();
+    for (const stmt of ast.program.body) {
+      collectLocalBindingsFromStatement(stmt, locallyBound);
+    }
+    ast.program.body = ast.program.body.filter((stmt) => {
+      if (!t__namespace.isExpressionStatement(stmt)) return true;
+      const refs = collectIdentifiersFromNode(stmt);
+      return [...refs].some((name) => locallyBound.has(name));
+    });
+  }
+  if (ast.program.body.length === 0) {
+    ast.program.directives = [];
+  }
+  return routerUtils.generateFromAst(ast, {
+    sourceMaps: true,
+    sourceFileName: opts.filename,
+    filename: opts.filename
+  });
+}
+function compileCodeSplitSharedRoute(opts) {
+  const ast = routerUtils.parseAst(opts);
+  const refIdents = routerUtils.findReferencedIdentifiers(ast);
+  const localBindings = /* @__PURE__ */ new Set();
+  for (const node of ast.program.body) {
+    collectLocalBindingsFromStatement(node, localBindings);
+  }
+  localBindings.delete("Route");
+  const declMap = buildDeclarationMap(ast);
+  const depGraph = buildDependencyGraph(declMap, localBindings);
+  const keepBindings = new Set(opts.sharedBindings);
+  keepBindings.delete("Route");
+  expandTransitively(keepBindings, depGraph);
+  ast.program.body = ast.program.body.filter((stmt) => {
+    if (t__namespace.isImportDeclaration(stmt)) return true;
+    const decl = t__namespace.isExportNamedDeclaration(stmt) && stmt.declaration ? stmt.declaration : stmt;
+    if (t__namespace.isVariableDeclaration(decl)) {
+      decl.declarations = decl.declarations.filter((declarator) => {
+        const names = collectIdentifiersFromPattern(declarator.id);
+        return names.some((n) => keepBindings.has(n));
+      });
+      if (decl.declarations.length === 0) return false;
+      if (t__namespace.isExportNamedDeclaration(stmt) && stmt.declaration) {
+        return true;
       }
+      return true;
+    } else if (t__namespace.isFunctionDeclaration(decl) && decl.id) {
+      return keepBindings.has(decl.id.name);
+    } else if (t__namespace.isClassDeclaration(decl) && decl.id) {
+      return keepBindings.has(decl.id.name);
+    }
+    return false;
+  });
+  ast.program.body = ast.program.body.map((stmt) => {
+    if (t__namespace.isExportNamedDeclaration(stmt) && stmt.declaration) {
+      return stmt.declaration;
     }
+    return stmt;
   });
+  const exportNames = [...opts.sharedBindings].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  const exportSpecifiers = exportNames.map(
+    (name) => t__namespace.exportSpecifier(t__namespace.identifier(name), t__namespace.identifier(name))
+  );
+  if (exportSpecifiers.length > 0) {
+    const exportDecl = t__namespace.exportNamedDeclaration(null, exportSpecifiers);
+    ast.program.body.push(exportDecl);
+    babel.traverse(ast, {
+      Program(programPath) {
+        const bodyPaths = programPath.get("body");
+        const last = bodyPaths[bodyPaths.length - 1];
+        if (last && last.isExportNamedDeclaration()) {
+          last.traverse({
+            Identifier(identPath) {
+              if (identPath.parentPath.isExportSpecifier() && identPath.key === "local") {
+                refIdents.add(identPath);
+              }
+            }
+          });
+        }
+        programPath.stop();
+      }
+    });
+  }
   routerUtils.deadCodeElimination(ast, refIdents);
+  if (ast.program.body.length === 0) {
+    ast.program.directives = [];
+  }
   return routerUtils.generateFromAst(ast, {
     sourceMaps: true,
     sourceFileName: opts.filename,
@@ -678,6 +1170,37 @@ function getImportSpecifierAndPathFromLocalName(programPath, name) {
   });
   return { specifier, path };
 }
+function collectIdentifiersFromPattern(node) {
+  if (!node) {
+    return [];
+  }
+  if (t__namespace.isIdentifier(node)) {
+    return [node.name];
+  }
+  if (t__namespace.isAssignmentPattern(node)) {
+    return collectIdentifiersFromPattern(node.left);
+  }
+  if (t__namespace.isRestElement(node)) {
+    return collectIdentifiersFromPattern(node.argument);
+  }
+  if (t__namespace.isObjectPattern(node)) {
+    return node.properties.flatMap((prop) => {
+      if (t__namespace.isObjectProperty(prop)) {
+        return collectIdentifiersFromPattern(prop.value);
+      }
+      if (t__namespace.isRestElement(prop)) {
+        return collectIdentifiersFromPattern(prop.argument);
+      }
+      return [];
+    });
+  }
+  if (t__namespace.isArrayPattern(node)) {
+    return node.elements.flatMap(
+      (element) => collectIdentifiersFromPattern(element)
+    );
+  }
+  return [];
+}
 function resolveIdentifier(path, node) {
   if (t__namespace.isIdentifier(node)) {
     const binding = path.scope.getBinding(node.name);
@@ -696,6 +1219,25 @@ function resolveIdentifier(path, node) {
 function removeIdentifierLiteral(path, node) {
   const binding = path.scope.getBinding(node.name);
   if (binding) {
+    if (t__namespace.isVariableDeclarator(binding.path.node) && t__namespace.isObjectPattern(binding.path.node.id)) {
+      const objectPattern = binding.path.node.id;
+      objectPattern.properties = objectPattern.properties.filter((prop) => {
+        if (!t__namespace.isObjectProperty(prop)) {
+          return true;
+        }
+        if (t__namespace.isIdentifier(prop.value) && prop.value.name === node.name) {
+          return false;
+        }
+        if (t__namespace.isAssignmentPattern(prop.value) && t__namespace.isIdentifier(prop.value.left) && prop.value.left.name === node.name) {
+          return false;
+        }
+        return true;
+      });
+      if (objectPattern.properties.length === 0) {
+        binding.path.remove();
+      }
+      return;
+    }
     binding.path.remove();
   }
 }
@@ -711,6 +1253,11 @@ function hasExport(ast, node) {
                 if (decl.id.name === node.name) {
                   found = true;
                 }
+              } else if (t__namespace.isObjectPattern(decl.id) || t__namespace.isArrayPattern(decl.id)) {
+                const names = collectIdentifiersFromPattern(decl.id);
+                if (names.includes(node.name)) {
+                  found = true;
+                }
               }
             }
           });
@@ -754,6 +1301,12 @@ function removeExports(ast, node) {
                   path.remove();
                   removed = true;
                 }
+              } else if (t__namespace.isObjectPattern(decl.id) || t__namespace.isArrayPattern(decl.id)) {
+                const names = collectIdentifiersFromPattern(decl.id);
+                if (names.includes(node.name)) {
+                  path.remove();
+                  removed = true;
+                }
               }
             }
           });
@@ -785,7 +1338,19 @@ function removeExports(ast, node) {
   });
   return removed;
 }
+exports.addSharedSearchParamToFilename = addSharedSearchParamToFilename;
+exports.buildDeclarationMap = buildDeclarationMap;
+exports.buildDependencyGraph = buildDependencyGraph;
+exports.collectIdentifiersFromNode = collectIdentifiersFromNode;
+exports.collectLocalBindingsFromStatement = collectLocalBindingsFromStatement;
+exports.collectModuleLevelRefsFromNode = collectModuleLevelRefsFromNode;
 exports.compileCodeSplitReferenceRoute = compileCodeSplitReferenceRoute;
+exports.compileCodeSplitSharedRoute = compileCodeSplitSharedRoute;
 exports.compileCodeSplitVirtualRoute = compileCodeSplitVirtualRoute;
+exports.computeSharedBindings = computeSharedBindings;
 exports.detectCodeSplitGroupingsFromRoute = detectCodeSplitGroupingsFromRoute;
+exports.expandDestructuredDeclarations = expandDestructuredDeclarations;
+exports.expandSharedDestructuredDeclarators = expandSharedDestructuredDeclarators;
+exports.expandTransitively = expandTransitively;
+exports.removeBindingsDependingOnRoute = removeBindingsDependingOnRoute;
 //# sourceMappingURL=compilers.cjs.map