one 1.25.16 → 1.26.0

package/dist/esm/vite/plugins/clientTreeShakePlugin.native.js

@@ -1,8 +1,6 @@
 import { extname, relative } from "path";
-import BabelGenerate from "@babel/generator";
-import { parse } from "@babel/parser";
-import BabelTraverse from "@babel/traverse";
-import { deadCodeElimination, findReferencedIdentifiers } from "babel-dead-code-elimination";
+import MagicString from "magic-string";
+import { parseSync } from "oxc-parser";
 import { EMPTY_LOADER_STRING, makeLoaderRouteIdStub } from "../constants.native.js";
 function _instanceof(left, right) {
   if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
@@ -11,53 +9,10 @@ function _instanceof(left, right) {
     return left instanceof right;
   }
 }
-var traverse = BabelTraverse["default"] || BabelTraverse;
-var generate = BabelGenerate["default"] || BabelGenerate;
-function collectTypeImports(ast) {
-  var typeImports = [];
-  traverse(ast, {
-    ImportDeclaration(path) {
-      if (path.node.importKind === "type") {
-        typeImports.push(path.node);
-      }
-    }
-  });
-  return typeImports;
-}
-function restoreTypeImports(ast, typeImports) {
-  if (typeImports.length === 0) return;
-  var existingSources = /* @__PURE__ */new Set();
-  traverse(ast, {
-    ImportDeclaration(path) {
-      if (path.node.importKind === "type") {
-        existingSources.add(path.node.source.value);
-      }
-    }
-  });
-  var _iteratorNormalCompletion = true,
-    _didIteratorError = false,
-    _iteratorError = void 0;
-  try {
-    for (var _iterator = typeImports[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var typeImport = _step.value;
-      if (!existingSources.has(typeImport.source.value)) {
-        ast.program.body.unshift(typeImport);
-      }
-    }
-  } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
-      }
-    } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
-      }
-    }
-  }
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 var clientTreeShakePlugin = function (opts) {
   var _ref, _ref1;
@@ -90,97 +45,1387 @@ var clientTreeShakePlugin = function (opts) {
     }
   };
 };
+function extractPatternBindings(node, names) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      names.add(node.name);
+      break;
+    case "ObjectPattern":
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = node.properties[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var prop = _step.value;
+          if (prop.type === "Property") {
+            extractPatternBindings(prop.value, names);
+          } else if (prop.type === "RestElement") {
+            extractPatternBindings(prop.argument, names);
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      break;
+    case "ArrayPattern":
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = node.elements[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var element = _step1.value;
+          if (element) {
+            extractPatternBindings(element, names);
+          }
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      break;
+    case "AssignmentPattern":
+      extractPatternBindings(node.left, names);
+      break;
+    case "RestElement":
+      extractPatternBindings(node.argument, names);
+      break;
+    case "TSParameterProperty":
+      extractPatternBindings(node.parameter, names);
+      break;
+  }
+}
+function getReferencedIdentifiers(rootNode, candidateNames) {
+  var referenced = /* @__PURE__ */new Set();
+  var scopeStack = [];
+  function isShadowed(name) {
+    for (var i = scopeStack.length - 1; i >= 0; i--) {
+      if (scopeStack[i].has(name)) return true;
+    }
+    return false;
+  }
+  function checkIdentifier(name) {
+    if (!isShadowed(name) && candidateNames.has(name)) {
+      referenced.add(name);
+    }
+  }
+  function walk(node) {
+    if (!node || (typeof node === "undefined" ? "undefined" : _type_of(node)) !== "object") return;
+    if (node.type === "TSTypeAnnotation" || node.type === "TSTypeReference" || node.type === "TSTypeAliasDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSTypeParameterDeclaration" || node.type === "TSTypeParameterInstantiation") {
+      return;
+    }
+    if (node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression") {
+      walk(node.expression);
+      return;
+    }
+    function walkPatternExpressions(pat) {
+      if (!pat || (typeof pat === "undefined" ? "undefined" : _type_of(pat)) !== "object") return;
+      switch (pat.type) {
+        case "AssignmentPattern":
+          walk(pat.right);
+          walkPatternExpressions(pat.left);
+          break;
+        case "ObjectPattern":
+          var _iteratorNormalCompletion8 = true,
+            _didIteratorError8 = false,
+            _iteratorError8 = void 0;
+          try {
+            for (var _iterator8 = pat.properties[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+              var prop = _step8.value;
+              if (prop.type === "Property") {
+                if (prop.computed) {
+                  walk(prop.key);
+                }
+                walkPatternExpressions(prop.value);
+              } else if (prop.type === "RestElement") {
+                walkPatternExpressions(prop.argument);
+              }
+            }
+          } catch (err) {
+            _didIteratorError8 = true;
+            _iteratorError8 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+                _iterator8.return();
+              }
+            } finally {
+              if (_didIteratorError8) {
+                throw _iteratorError8;
+              }
+            }
+          }
+          break;
+        case "ArrayPattern":
+          var _iteratorNormalCompletion12 = true,
+            _didIteratorError12 = false,
+            _iteratorError12 = void 0;
+          try {
+            for (var _iterator12 = pat.elements[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+              var element = _step12.value;
+              if (element) {
+                walkPatternExpressions(element);
+              }
+            }
+          } catch (err) {
+            _didIteratorError12 = true;
+            _iteratorError12 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+                _iterator12.return();
+              }
+            } finally {
+              if (_didIteratorError12) {
+                throw _iteratorError12;
+              }
+            }
+          }
+          break;
+        case "RestElement":
+          walkPatternExpressions(pat.argument);
+          break;
+        case "TSParameterProperty":
+          walkPatternExpressions(pat.parameter);
+          break;
+      }
+    }
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      let addVars2 = function (n) {
+        if (!n || (typeof n === "undefined" ? "undefined" : _type_of(n)) !== "object") return;
+        if (n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression") {
+          return;
+        }
+        if (n.type === "VariableDeclaration" && n.kind === "var") {
+          var _iteratorNormalCompletion8 = true,
+            _didIteratorError8 = false,
+            _iteratorError8 = void 0;
+          try {
+            for (var _iterator8 = n.declarations[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+              var d = _step8.value;
+              extractPatternBindings(d.id, scope);
+            }
+          } catch (err) {
+            _didIteratorError8 = true;
+            _iteratorError8 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+                _iterator8.return();
+              }
+            } finally {
+              if (_didIteratorError8) {
+                throw _iteratorError8;
+              }
+            }
+          }
+        }
+        var _iteratorNormalCompletion12 = true,
+          _didIteratorError12 = false,
+          _iteratorError12 = void 0;
+        try {
+          for (var _iterator12 = Object.keys(n)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+            var k = _step12.value;
+            if (k === "parent") continue;
+            var val = n[k];
+            if (Array.isArray(val)) {
+              var _iteratorNormalCompletion22 = true,
+                _didIteratorError22 = false,
+                _iteratorError22 = void 0;
+              try {
+                for (var _iterator22 = val[Symbol.iterator](), _step22; !(_iteratorNormalCompletion22 = (_step22 = _iterator22.next()).done); _iteratorNormalCompletion22 = true) {
+                  var item2 = _step22.value;
+                  addVars2(item2);
+                }
+              } catch (err) {
+                _didIteratorError22 = true;
+                _iteratorError22 = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion22 && _iterator22.return != null) {
+                    _iterator22.return();
+                  }
+                } finally {
+                  if (_didIteratorError22) {
+                    throw _iteratorError22;
+                  }
+                }
+              }
+            } else if (val && (typeof val === "undefined" ? "undefined" : _type_of(val)) === "object") {
+              addVars2(val);
+            }
+          }
+        } catch (err) {
+          _didIteratorError12 = true;
+          _iteratorError12 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+              _iterator12.return();
+            }
+          } finally {
+            if (_didIteratorError12) {
+              throw _iteratorError12;
+            }
+          }
+        }
+      };
+      var addVars = addVars2;
+      var scope = /* @__PURE__ */new Set();
+      if (node.type === "FunctionExpression" && node.id) {
+        scope.add(node.id.name);
+      }
+      if (node.params) {
+        var _iteratorNormalCompletion = true,
+          _didIteratorError = false,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = node.params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var param = _step.value;
+            walkPatternExpressions(param);
+            extractPatternBindings(param, scope);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+      }
+      addVars2(node.body);
+      scopeStack.push(scope);
+      walk(node.body);
+      scopeStack.pop();
+      return;
+    }
+    if (node.type === "BlockStatement") {
+      var scope1 = /* @__PURE__ */new Set();
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = node.body[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var stmt = _step1.value;
+          if (stmt.type === "VariableDeclaration" && (stmt.kind === "let" || stmt.kind === "const")) {
+            var _iteratorNormalCompletion2 = true,
+              _didIteratorError2 = false,
+              _iteratorError2 = void 0;
+            try {
+              for (var _iterator2 = stmt.declarations[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                var decl = _step2.value;
+                extractPatternBindings(decl.id, scope1);
+              }
+            } catch (err) {
+              _didIteratorError2 = true;
+              _iteratorError2 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                  _iterator2.return();
+                }
+              } finally {
+                if (_didIteratorError2) {
+                  throw _iteratorError2;
+                }
+              }
+            }
+          } else if (stmt.type === "FunctionDeclaration" && stmt.id) {
+            scope1.add(stmt.id.name);
+          } else if (stmt.type === "ClassDeclaration" && stmt.id) {
+            scope1.add(stmt.id.name);
+          }
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      scopeStack.push(scope1);
+      var _iteratorNormalCompletion3 = true,
+        _didIteratorError3 = false,
+        _iteratorError3 = void 0;
+      try {
+        for (var _iterator3 = node.body[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          var stmt1 = _step3.value;
+          walk(stmt1);
+        }
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+            _iterator3.return();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+      scopeStack.pop();
+      return;
+    }
+    if (node.type === "CatchClause") {
+      var scope2 = /* @__PURE__ */new Set();
+      if (node.param) {
+        extractPatternBindings(node.param, scope2);
+      }
+      scopeStack.push(scope2);
+      walk(node.body);
+      scopeStack.pop();
+      return;
+    }
+    if (node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement") {
+      var scope3 = /* @__PURE__ */new Set();
+      var initOrLeft = node.init || node.left;
+      if (initOrLeft && initOrLeft.type === "VariableDeclaration" && initOrLeft.kind !== "var") {
+        var _iteratorNormalCompletion4 = true,
+          _didIteratorError4 = false,
+          _iteratorError4 = void 0;
+        try {
+          for (var _iterator4 = initOrLeft.declarations[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+            var decl1 = _step4.value;
+            extractPatternBindings(decl1.id, scope3);
+          }
+        } catch (err) {
+          _didIteratorError4 = true;
+          _iteratorError4 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+              _iterator4.return();
+            }
+          } finally {
+            if (_didIteratorError4) {
+              throw _iteratorError4;
+            }
+          }
+        }
+      }
+      scopeStack.push(scope3);
+      if (node.init) walk(node.init);
+      if (node.left) walk(node.left);
+      if (node.right) walk(node.right);
+      if (node.test) walk(node.test);
+      if (node.update) walk(node.update);
+      walk(node.body);
+      scopeStack.pop();
+      return;
+    }
+    if (node.type === "Identifier") {
+      checkIdentifier(node.name);
+      return;
+    }
+    if (node.type === "JSXOpeningElement") {
+      if (node.name) {
+        if (node.name.type === "JSXIdentifier") {
+          if (node.name.name && /^[A-Z]/.test(node.name.name)) {
+            checkIdentifier(node.name.name);
+          }
+        } else if (node.name.type === "JSXMemberExpression") {
+          var rootObj = node.name.object;
+          while (rootObj && rootObj.type === "JSXMemberExpression") {
+            rootObj = rootObj.object;
+          }
+          if (rootObj && rootObj.type === "JSXIdentifier") {
+            checkIdentifier(rootObj.name);
+          }
+        }
+      }
+      if (node.attributes) {
+        var _iteratorNormalCompletion5 = true,
+          _didIteratorError5 = false,
+          _iteratorError5 = void 0;
+        try {
+          for (var _iterator5 = node.attributes[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+            var attr = _step5.value;
+            walk(attr);
+          }
+        } catch (err) {
+          _didIteratorError5 = true;
+          _iteratorError5 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+              _iterator5.return();
+            }
+          } finally {
+            if (_didIteratorError5) {
+              throw _iteratorError5;
+            }
+          }
+        }
+      }
+      return;
+    }
+    if (node.type === "JSXAttribute") {
+      if (node.value) walk(node.value);
+      return;
+    }
+    if (node.type === "JSXClosingElement") {
+      return;
+    }
+    if (node.type === "Property") {
+      if (node.computed) {
+        walk(node.key);
+      }
+      walk(node.value);
+      return;
+    }
+    if (node.type === "MemberExpression") {
+      walk(node.object);
+      if (node.computed) {
+        walk(node.property);
+      }
+      return;
+    }
+    if (node.type === "VariableDeclarator") {
+      walkPatternExpressions(node.id);
+      if (node.init) {
+        walk(node.init);
+      }
+      return;
+    }
+    if (node.type === "ExportSpecifier") {
+      if (node.local && node.local.type === "Identifier") {
+        checkIdentifier(node.local.name);
+      }
+      return;
+    }
+    var _iteratorNormalCompletion6 = true,
+      _didIteratorError6 = false,
+      _iteratorError6 = void 0;
+    try {
+      for (var _iterator6 = Object.keys(node)[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+        var key = _step6.value;
+        if (key === "parent") continue;
+        var child = node[key];
+        if (Array.isArray(child)) {
+          var _iteratorNormalCompletion7 = true,
+            _didIteratorError7 = false,
+            _iteratorError7 = void 0;
+          try {
+            for (var _iterator7 = child[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+              var item = _step7.value;
+              if (item && (typeof item === "undefined" ? "undefined" : _type_of(item)) === "object") walk(item);
+            }
+          } catch (err) {
+            _didIteratorError7 = true;
+            _iteratorError7 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+                _iterator7.return();
+              }
+            } finally {
+              if (_didIteratorError7) {
+                throw _iteratorError7;
+              }
+            }
+          }
+        } else if (child && (typeof child === "undefined" ? "undefined" : _type_of(child)) === "object") {
+          walk(child);
+        }
+      }
+    } catch (err) {
+      _didIteratorError6 = true;
+      _iteratorError6 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+          _iterator6.return();
+        }
+      } finally {
+        if (_didIteratorError6) {
+          throw _iteratorError6;
+        }
+      }
+    }
+  }
+  walk(rootNode);
+  return referenced;
+}
 async function transformTreeShakeClient(code, id, root) {
   var routerRoot = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "app";
   if (!/generateStaticParams|loader/.test(code)) {
     return;
   }
-  var ast;
+  var isProd = process.env.NODE_ENV === "production";
+  var filename = (id || "file.tsx").split("?")[0].split("#")[0];
+  var parseResult;
   try {
-    ast = parse(code, {
-      sourceType: "module",
-      plugins: ["typescript", "jsx"]
-    });
+    parseResult = parseSync(filename, code);
+    if (parseResult.errors && parseResult.errors.length > 0) {
+      var errorMessage = parseResult.errors.map(function (e) {
+        return e.message;
+      }).join("\n");
+      if (isProd) {
+        throw new Error(`[one] Failed to parse ${id} with server exports:
+${errorMessage}`);
+      }
+      console.warn(`[one] Skipping tree shaking for ${id} due to syntax error:`, errorMessage);
+      return;
+    }
   } catch (error) {
-    var errorMessage = _instanceof(error, Error) ? error.message : String(error);
-    console.warn(`[one] Skipping tree shaking for ${id} due to syntax error:`, errorMessage);
+    if (isProd) {
+      throw _instanceof(error, Error) ? error : new Error(String(error));
+    }
+    var errorMessage1 = _instanceof(error, Error) ? error.message : String(error);
+    console.warn(`[one] Skipping tree shaking for ${id} due to syntax error:`, errorMessage1);
     return;
   }
-  var referenced;
+  var ast = parseResult.program;
   try {
-    referenced = findReferencedIdentifiers(ast);
+    return doTreeShakeClient(code, id, root, ast, routerRoot);
   } catch (error) {
-    var errorMessage1 = _instanceof(error, Error) ? error.message : String(error);
-    console.warn(`[one] Skipping tree shaking for ${id} due to identifier analysis error:`, errorMessage1);
+    if (isProd) {
+      throw _instanceof(error, Error) ? error : new Error(String(error));
+    }
+    var errorMessage2 = _instanceof(error, Error) ? error.message : String(error);
+    console.warn(`[one] Skipping tree shaking for ${id} due to analysis error:`, errorMessage2);
     return;
   }
+}
+function doTreeShakeClient(code, id, root, ast, routerRoot) {
   var removed = {
     loader: false,
     generateStaticParams: false
   };
+  var serverExportStmts = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
   try {
-    traverse(ast, {
-      ExportNamedDeclaration(path) {
-        if (path.node.declaration && path.node.declaration.type === "FunctionDeclaration") {
-          if (!path.node.declaration.id) return;
-          var functionName = path.node.declaration.id.name;
-          if (functionName === "loader" || functionName === "generateStaticParams") {
-            path.remove();
-            removed[functionName] = true;
-          }
-        } else if (path.node.declaration && path.node.declaration.type === "VariableDeclaration") {
-          path.node.declaration.declarations.forEach(function (declarator, index) {
-            if (declarator.id.type === "Identifier" && (declarator.id.name === "loader" || declarator.id.name === "generateStaticParams")) {
-              var declaration = path.get("declaration.declarations." + index);
-              if (!Array.isArray(declaration) && declaration) {
-                ;
-                declaration.remove();
-                removed[declarator.id.name] = true;
+    for (var _iterator = ast.body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var stmt = _step.value;
+      if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+        if (stmt.declaration.type === "FunctionDeclaration") {
+          var _stmt_declaration_id;
+          var fnName = (_stmt_declaration_id = stmt.declaration.id) === null || _stmt_declaration_id === void 0 ? void 0 : _stmt_declaration_id.name;
+          if (fnName === "loader" || fnName === "generateStaticParams") {
+            removed[fnName] = true;
+            serverExportStmts.set(stmt, {
+              names: /* @__PURE__ */new Set([fnName]),
+              replaceAll: true,
+              declaratorsToRemove: /* @__PURE__ */new Set()
+            });
+          }
+        } else if (stmt.declaration.type === "VariableDeclaration") {
+          var found = [];
+          var _iteratorNormalCompletion1 = true,
+            _didIteratorError1 = false,
+            _iteratorError1 = void 0;
+          try {
+            for (var _iterator1 = stmt.declaration.declarations[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+              var d = _step1.value;
+              var _d_id;
+              if (((_d_id = d.id) === null || _d_id === void 0 ? void 0 : _d_id.type) === "Identifier" && (d.id.name === "loader" || d.id.name === "generateStaticParams")) {
+                found.push(d);
+                removed[d.id.name] = true;
               }
             }
-          });
+          } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+              }
+            } finally {
+              if (_didIteratorError1) {
+                throw _iteratorError1;
+              }
+            }
+          }
+          if (found.length > 0) {
+            serverExportStmts.set(stmt, {
+              names: new Set(found.map(function (d7) {
+                return d7.id.name;
+              })),
+              replaceAll: found.length === stmt.declaration.declarations.length,
+              declaratorsToRemove: new Set(found)
+            });
+          }
         }
       }
-    });
-  } catch (error) {
-    var errorMessage2 = _instanceof(error, Error) ? error.message : String(error);
-    console.warn(`[one] Skipping tree shaking for ${id} due to traversal error:`, errorMessage2);
-    return;
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
   }
-  var removedFunctions = Object.keys(removed).filter(function (key) {
-    return removed[key];
+  var removedFunctions = Object.keys(removed).filter(function (k) {
+    return removed[k];
   });
-  if (removedFunctions.length) {
+  if (removedFunctions.length === 0) {
+    return;
+  }
+  var moduleBindings = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator2 = ast.body[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var stmt1 = _step2.value;
+      if (stmt1.type === "ImportDeclaration") {
+        var isDeclType = stmt1.importKind === "type";
+        var _iteratorNormalCompletion3 = true,
+          _didIteratorError3 = false,
+          _iteratorError3 = void 0;
+        try {
+          for (var _iterator3 = stmt1.specifiers[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+            var sp = _step3.value;
+            var isType = isDeclType || sp.importKind === "type";
+            moduleBindings.set(sp.local.name, {
+              kind: "import",
+              stmt: stmt1,
+              node: sp,
+              isType
+            });
+          }
+        } catch (err) {
+          _didIteratorError3 = true;
+          _iteratorError3 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+              _iterator3.return();
+            }
+          } finally {
+            if (_didIteratorError3) {
+              throw _iteratorError3;
+            }
+          }
+        }
+      } else if (stmt1.type === "ExportNamedDeclaration" && stmt1.declaration) {
+        var decl = stmt1.declaration;
+        if (decl.type === "FunctionDeclaration" && decl.id) {
+          moduleBindings.set(decl.id.name, {
+            kind: "function",
+            stmt: stmt1,
+            node: decl
+          });
+        } else if (decl.type === "VariableDeclaration") {
+          var _iteratorNormalCompletion4 = true,
+            _didIteratorError4 = false,
+            _iteratorError4 = void 0;
+          try {
+            for (var _iterator4 = decl.declarations[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+              var d1 = _step4.value;
+              var names = /* @__PURE__ */new Set();
+              extractPatternBindings(d1.id, names);
+              var _iteratorNormalCompletion5 = true,
+                _didIteratorError5 = false,
+                _iteratorError5 = void 0;
+              try {
+                for (var _iterator5 = names[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+                  var name = _step5.value;
+                  moduleBindings.set(name, {
+                    kind: "variable",
+                    stmt: stmt1,
+                    node: d1
+                  });
+                }
+              } catch (err) {
+                _didIteratorError5 = true;
+                _iteratorError5 = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                    _iterator5.return();
+                  }
+                } finally {
+                  if (_didIteratorError5) {
+                    throw _iteratorError5;
+                  }
+                }
+              }
+            }
+          } catch (err) {
+            _didIteratorError4 = true;
+            _iteratorError4 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                _iterator4.return();
+              }
+            } finally {
+              if (_didIteratorError4) {
+                throw _iteratorError4;
+              }
+            }
+          }
+        } else if (decl.type === "ClassDeclaration" && decl.id) {
+          moduleBindings.set(decl.id.name, {
+            kind: "class",
+            stmt: stmt1,
+            node: decl
+          });
+        }
+      } else if (stmt1.type === "FunctionDeclaration" && stmt1.id) {
+        moduleBindings.set(stmt1.id.name, {
+          kind: "function",
+          stmt: stmt1,
+          node: stmt1
+        });
+      } else if (stmt1.type === "VariableDeclaration") {
+        var _iteratorNormalCompletion6 = true,
+          _didIteratorError6 = false,
+          _iteratorError6 = void 0;
+        try {
+          for (var _iterator6 = stmt1.declarations[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+            var d2 = _step6.value;
+            var names1 = /* @__PURE__ */new Set();
+            extractPatternBindings(d2.id, names1);
+            var _iteratorNormalCompletion7 = true,
+              _didIteratorError7 = false,
+              _iteratorError7 = void 0;
+            try {
+              for (var _iterator7 = names1[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+                var name1 = _step7.value;
+                moduleBindings.set(name1, {
+                  kind: "variable",
+                  stmt: stmt1,
+                  node: d2
+                });
+              }
+            } catch (err) {
+              _didIteratorError7 = true;
+              _iteratorError7 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+                  _iterator7.return();
+                }
+              } finally {
+                if (_didIteratorError7) {
+                  throw _iteratorError7;
+                }
+              }
+            }
+          }
+        } catch (err) {
+          _didIteratorError6 = true;
+          _iteratorError6 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+              _iterator6.return();
+            }
+          } finally {
+            if (_didIteratorError6) {
+              throw _iteratorError6;
+            }
+          }
+        }
+      } else if (stmt1.type === "ClassDeclaration" && stmt1.id) {
+        moduleBindings.set(stmt1.id.name, {
+          kind: "class",
+          stmt: stmt1,
+          node: stmt1
+        });
+      } else if (stmt1.type === "TSEnumDeclaration" && stmt1.id) {
+        moduleBindings.set(stmt1.id.name, {
+          kind: "enum",
+          stmt: stmt1,
+          node: stmt1
+        });
+      }
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
     try {
-      var typeImports = collectTypeImports(ast);
-      deadCodeElimination(ast, referenced);
-      restoreTypeImports(ast, typeImports);
-      var out = generate(ast, {
-        retainLines: true
-      });
-      var codeOut = out.code + "\n\n" + removedFunctions.map(function (key) {
-        if (key === "loader") {
-          if (root) {
-            var fromRoot = relative(root, id).replace(/\\/g, "/");
-            var prefix = routerRoot.replace(/^\.\//, "").replace(/\/$/, "") + "/";
-            var routeId = "./" + (fromRoot.startsWith(prefix) ? fromRoot.slice(prefix.length) : fromRoot);
-            return makeLoaderRouteIdStub(routeId);
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
+  var allBindingNames = new Set(moduleBindings.keys());
+  var topLevelDeps = /* @__PURE__ */new Map();
+  var clientRootDeps = /* @__PURE__ */new Set();
+  var _iteratorNormalCompletion8 = true,
+    _didIteratorError8 = false,
+    _iteratorError8 = void 0;
+  try {
+    for (var _iterator8 = moduleBindings[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+      var [name2, info] = _step8.value;
+      if (info.kind === "import") {
+        topLevelDeps.set(name2, /* @__PURE__ */new Set());
+      } else if (info.kind === "function") {
+        topLevelDeps.set(name2, getReferencedIdentifiers(info.node, allBindingNames));
+      } else if (info.kind === "variable") {
+        var deps = getReferencedIdentifiers(info.node, allBindingNames);
+        deps.delete(name2);
+        topLevelDeps.set(name2, deps);
+      } else if (info.kind === "class") {
+        topLevelDeps.set(name2, getReferencedIdentifiers(info.node, allBindingNames));
+      } else if (info.kind === "enum") {
+        topLevelDeps.set(name2, getReferencedIdentifiers(info.node, allBindingNames));
+      }
+    }
+  } catch (err) {
+    _didIteratorError8 = true;
+    _iteratorError8 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+        _iterator8.return();
+      }
+    } finally {
+      if (_didIteratorError8) {
+        throw _iteratorError8;
+      }
+    }
+  }
+  var serverNeeded = /* @__PURE__ */new Set();
+  var serverQueue = [];
+  var _iteratorNormalCompletion9 = true,
+    _didIteratorError9 = false,
+    _iteratorError9 = void 0;
+  try {
+    for (var _iterator9 = removedFunctions[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
+      var fn = _step9.value;
+      var deps1 = topLevelDeps.get(fn);
+      if (deps1) {
+        var _iteratorNormalCompletion10 = true,
+          _didIteratorError10 = false,
+          _iteratorError10 = void 0;
+        try {
+          for (var _iterator10 = deps1[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
+            var dep = _step10.value;
+            serverQueue.push(dep);
+          }
+        } catch (err) {
+          _didIteratorError10 = true;
+          _iteratorError10 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
+              _iterator10.return();
+            }
+          } finally {
+            if (_didIteratorError10) {
+              throw _iteratorError10;
+            }
           }
-          return EMPTY_LOADER_STRING;
         }
-        return `export function generateStaticParams() {};`;
-      }).join("\n");
-      console.info(` \u{1F9F9} [one]      ${relative(process.cwd(), id)} removed ${removedFunctions.length} server-only exports`);
-      return {
-        code: codeOut,
-        map: out.map
-      };
-    } catch (error) {
-      var errorMessage3 = _instanceof(error, Error) ? error.message : String(error);
-      console.warn(`[one] Skipping tree shaking for ${id} due to code generation error:`, errorMessage3);
-      return;
+      }
+    }
+  } catch (err) {
+    _didIteratorError9 = true;
+    _iteratorError9 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
+        _iterator9.return();
+      }
+    } finally {
+      if (_didIteratorError9) {
+        throw _iteratorError9;
+      }
     }
   }
+  while (serverQueue.length > 0) {
+    var name3 = serverQueue.shift();
+    if (serverNeeded.has(name3)) continue;
+    serverNeeded.add(name3);
+    var deps2 = topLevelDeps.get(name3);
+    if (deps2) {
+      var _iteratorNormalCompletion11 = true,
+        _didIteratorError11 = false,
+        _iteratorError11 = void 0;
+      try {
+        for (var _iterator11 = deps2[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
+          var dep1 = _step11.value;
+          if (!serverNeeded.has(dep1)) serverQueue.push(dep1);
+        }
+      } catch (err) {
+        _didIteratorError11 = true;
+        _iteratorError11 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
+            _iterator11.return();
+          }
+        } finally {
+          if (_didIteratorError11) {
+            throw _iteratorError11;
+          }
+        }
+      }
+    }
+  }
+  var _iteratorNormalCompletion12 = true,
+    _didIteratorError12 = false,
+    _iteratorError12 = void 0;
+  try {
+    for (var _iterator12 = ast.body[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+      var stmt2 = _step12.value;
+      if (stmt2.type === "ImportDeclaration") {
+        continue;
+      }
+      if (serverExportStmts.has(stmt2)) {
+        var _stmt_declaration;
+        var info1 = serverExportStmts.get(stmt2);
+        if (!info1.replaceAll && ((_stmt_declaration = stmt2.declaration) === null || _stmt_declaration === void 0 ? void 0 : _stmt_declaration.declarations)) {
+          var _iteratorNormalCompletion13 = true,
+            _didIteratorError13 = false,
+            _iteratorError13 = void 0;
+          try {
+            for (var _iterator13 = stmt2.declaration.declarations[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
+              var d3 = _step13.value;
+              if (!info1.declaratorsToRemove.has(d3)) {
+                var deps3 = getReferencedIdentifiers(d3, allBindingNames);
+                var _iteratorNormalCompletion14 = true,
+                  _didIteratorError14 = false,
+                  _iteratorError14 = void 0;
+                try {
+                  for (var _iterator14 = deps3[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) {
+                    var dep2 = _step14.value;
+                    clientRootDeps.add(dep2);
+                  }
+                } catch (err) {
+                  _didIteratorError14 = true;
+                  _iteratorError14 = err;
+                } finally {
+                  try {
+                    if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
+                      _iterator14.return();
+                    }
+                  } finally {
+                    if (_didIteratorError14) {
+                      throw _iteratorError14;
+                    }
+                  }
+                }
+              }
+            }
+          } catch (err) {
+            _didIteratorError13 = true;
+            _iteratorError13 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
+                _iterator13.return();
+              }
+            } finally {
+              if (_didIteratorError13) {
+                throw _iteratorError13;
+              }
+            }
+          }
+        }
+        continue;
+      }
+      if (stmt2.type === "VariableDeclaration") {
+        var allInServer = stmt2.declarations.every(function (d7) {
+          var names4 = /* @__PURE__ */new Set();
+          extractPatternBindings(d7.id, names4);
+          return names4.size > 0 && Array.from(names4).every(function (n) {
+            return serverNeeded.has(n);
+          });
+        });
+        if (!allInServer) {
+          var _iteratorNormalCompletion15 = true,
+            _didIteratorError15 = false,
+            _iteratorError15 = void 0;
+          try {
+            for (var _iterator15 = stmt2.declarations[Symbol.iterator](), _step15; !(_iteratorNormalCompletion15 = (_step15 = _iterator15.next()).done); _iteratorNormalCompletion15 = true) {
+              var d4 = _step15.value;
+              var names2 = /* @__PURE__ */new Set();
+              extractPatternBindings(d4.id, names2);
+              var inServer = names2.size > 0 && Array.from(names2).every(function (n) {
+                return serverNeeded.has(n);
+              });
+              if (!inServer) {
+                var deps4 = getReferencedIdentifiers(d4, allBindingNames);
+                var _iteratorNormalCompletion16 = true,
+                  _didIteratorError16 = false,
+                  _iteratorError16 = void 0;
+                try {
+                  for (var _iterator16 = deps4[Symbol.iterator](), _step16; !(_iteratorNormalCompletion16 = (_step16 = _iterator16.next()).done); _iteratorNormalCompletion16 = true) {
+                    var dep3 = _step16.value;
+                    clientRootDeps.add(dep3);
+                  }
+                } catch (err) {
+                  _didIteratorError16 = true;
+                  _iteratorError16 = err;
+                } finally {
+                  try {
+                    if (!_iteratorNormalCompletion16 && _iterator16.return != null) {
+                      _iterator16.return();
+                    }
+                  } finally {
+                    if (_didIteratorError16) {
+                      throw _iteratorError16;
+                    }
+                  }
+                }
+              }
+            }
+          } catch (err) {
+            _didIteratorError15 = true;
+            _iteratorError15 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion15 && _iterator15.return != null) {
+                _iterator15.return();
+              }
+            } finally {
+              if (_didIteratorError15) {
+                throw _iteratorError15;
+              }
+            }
+          }
+        }
+        continue;
+      }
+      if ((stmt2.type === "FunctionDeclaration" || stmt2.type === "ClassDeclaration" || stmt2.type === "TSEnumDeclaration") && stmt2.id && serverNeeded.has(stmt2.id.name)) {
+        continue;
+      }
+      var deps5 = getReferencedIdentifiers(stmt2, allBindingNames);
+      var _iteratorNormalCompletion17 = true,
+        _didIteratorError17 = false,
+        _iteratorError17 = void 0;
+      try {
+        for (var _iterator17 = deps5[Symbol.iterator](), _step17; !(_iteratorNormalCompletion17 = (_step17 = _iterator17.next()).done); _iteratorNormalCompletion17 = true) {
+          var dep4 = _step17.value;
+          clientRootDeps.add(dep4);
+        }
+      } catch (err) {
+        _didIteratorError17 = true;
+        _iteratorError17 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion17 && _iterator17.return != null) {
+            _iterator17.return();
+          }
+        } finally {
+          if (_didIteratorError17) {
+            throw _iteratorError17;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError12 = true;
+    _iteratorError12 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+        _iterator12.return();
+      }
+    } finally {
+      if (_didIteratorError12) {
+        throw _iteratorError12;
+      }
+    }
+  }
+  var clientNeeded = /* @__PURE__ */new Set();
+  var clientQueue = Array.from(clientRootDeps);
+  while (clientQueue.length > 0) {
+    var name4 = clientQueue.shift();
+    if (clientNeeded.has(name4)) continue;
+    clientNeeded.add(name4);
+    if (name4 === "loader" || name4 === "generateStaticParams") continue;
+    var deps6 = topLevelDeps.get(name4);
+    if (deps6) {
+      var _iteratorNormalCompletion18 = true,
+        _didIteratorError18 = false,
+        _iteratorError18 = void 0;
+      try {
+        for (var _iterator18 = deps6[Symbol.iterator](), _step18; !(_iteratorNormalCompletion18 = (_step18 = _iterator18.next()).done); _iteratorNormalCompletion18 = true) {
+          var dep5 = _step18.value;
+          if (!clientNeeded.has(dep5)) clientQueue.push(dep5);
+        }
+      } catch (err) {
+        _didIteratorError18 = true;
+        _iteratorError18 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion18 && _iterator18.return != null) {
+            _iterator18.return();
+          }
+        } finally {
+          if (_didIteratorError18) {
+            throw _iteratorError18;
+          }
+        }
+      }
+    }
+  }
+  var exclusiveServerBindings = /* @__PURE__ */new Set();
+  var _iteratorNormalCompletion19 = true,
+    _didIteratorError19 = false,
+    _iteratorError19 = void 0;
+  try {
+    for (var _iterator19 = serverNeeded[Symbol.iterator](), _step19; !(_iteratorNormalCompletion19 = (_step19 = _iterator19.next()).done); _iteratorNormalCompletion19 = true) {
+      var name5 = _step19.value;
+      if (!clientNeeded.has(name5)) {
+        exclusiveServerBindings.add(name5);
+      }
+    }
+  } catch (err) {
+    _didIteratorError19 = true;
+    _iteratorError19 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion19 && _iterator19.return != null) {
+        _iterator19.return();
+      }
+    } finally {
+      if (_didIteratorError19) {
+        throw _iteratorError19;
+      }
+    }
+  }
+  var s = new MagicString(code);
+  var _iteratorNormalCompletion20 = true,
+    _didIteratorError20 = false,
+    _iteratorError20 = void 0;
+  try {
+    for (var _iterator20 = serverExportStmts[Symbol.iterator](), _step20; !(_iteratorNormalCompletion20 = (_step20 = _iterator20.next()).done); _iteratorNormalCompletion20 = true) {
+      var [stmt3, info2] = _step20.value;
+      var stubs = [];
+      if (info2.names.has("loader")) {
+        if (root) {
+          var fromRoot = relative(root, id).replace(/\\/g, "/");
+          var prefix = routerRoot.replace(/^\.\//, "").replace(/\/$/, "") + "/";
+          var routeId = "./" + (fromRoot.startsWith(prefix) ? fromRoot.slice(prefix.length) : fromRoot);
+          stubs.push(makeLoaderRouteIdStub(routeId));
+        } else {
+          stubs.push(EMPTY_LOADER_STRING);
+        }
+      }
+      if (info2.names.has("generateStaticParams")) {
+        stubs.push("export function generateStaticParams() {};");
+      }
+      if (info2.replaceAll) {
+        s.overwrite(stmt3.start, stmt3.end, stubs.join("\n"));
+      } else {
+        var decl1 = stmt3.declaration;
+        for (var i = decl1.declarations.length - 1; i >= 0; i--) {
+          var d5 = decl1.declarations[i];
+          if (info2.declaratorsToRemove.has(d5)) {
+            if (i === 0) {
+              var next = decl1.declarations[1];
+              s.remove(d5.start, next.start);
+            } else {
+              var prev = decl1.declarations[i - 1];
+              s.remove(prev.end, d5.end);
+            }
+          }
+        }
+        s.appendRight(stmt3.end, "\n" + stubs.join("\n"));
+      }
+    }
+  } catch (err) {
+    _didIteratorError20 = true;
+    _iteratorError20 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion20 && _iterator20.return != null) {
+        _iterator20.return();
+      }
+    } finally {
+      if (_didIteratorError20) {
+        throw _iteratorError20;
+      }
+    }
+  }
+  var _iteratorNormalCompletion21 = true,
+    _didIteratorError21 = false,
+    _iteratorError21 = void 0;
+  try {
+    for (var _iterator21 = ast.body[Symbol.iterator](), _step21; !(_iteratorNormalCompletion21 = (_step21 = _iterator21.next()).done); _iteratorNormalCompletion21 = true) {
+      var stmt4 = _step21.value;
+      if (serverExportStmts.has(stmt4) || stmt4.type === "ImportDeclaration") continue;
+      if ((stmt4.type === "FunctionDeclaration" || stmt4.type === "ClassDeclaration" || stmt4.type === "TSEnumDeclaration") && stmt4.id && exclusiveServerBindings.has(stmt4.id.name)) {
+        var end = stmt4.end;
+        if (code[end] === ";") end++;
+        if (code[end] === "\r" && code[end + 1] === "\n") end += 2;else if (code[end] === "\n") end += 1;
+        s.remove(stmt4.start, end);
+      } else if (stmt4.type === "VariableDeclaration") {
+        var allExclusive = stmt4.declarations.every(function (d7) {
+          var names4 = /* @__PURE__ */new Set();
+          extractPatternBindings(d7.id, names4);
+          return Array.from(names4).every(function (n) {
+            return exclusiveServerBindings.has(n);
+          });
+        });
+        if (allExclusive) {
+          var end1 = stmt4.end;
+          if (code[end1] === ";") end1++;
+          if (code[end1] === "\r" && code[end1 + 1] === "\n") end1 += 2;else if (code[end1] === "\n") end1 += 1;
+          s.remove(stmt4.start, end1);
+        } else {
+          for (var i1 = stmt4.declarations.length - 1; i1 >= 0; i1--) {
+            var d6 = stmt4.declarations[i1];
+            var names3 = /* @__PURE__ */new Set();
+            extractPatternBindings(d6.id, names3);
+            if (Array.from(names3).every(function (n) {
+              return exclusiveServerBindings.has(n);
+            })) {
+              if (i1 === 0) {
+                var next1 = stmt4.declarations[1];
+                s.remove(d6.start, next1.start);
+              } else {
+                var prev1 = stmt4.declarations[i1 - 1];
+                s.remove(prev1.end, d6.end);
+              }
+            }
+          }
+        }
+      } else if (stmt4.type === "ClassDeclaration" && stmt4.id && exclusiveServerBindings.has(stmt4.id.name)) {
+        var end2 = stmt4.end;
+        if (code[end2] === ";") end2++;
+        if (code[end2] === "\r" && code[end2 + 1] === "\n") end2 += 2;else if (code[end2] === "\n") end2 += 1;
+        s.remove(stmt4.start, end2);
+      }
+    }
+  } catch (err) {
+    _didIteratorError21 = true;
+    _iteratorError21 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion21 && _iterator21.return != null) {
+        _iterator21.return();
+      }
+    } finally {
+      if (_didIteratorError21) {
+        throw _iteratorError21;
+      }
+    }
+  }
+  var _iteratorNormalCompletion22 = true,
+    _didIteratorError22 = false,
+    _iteratorError22 = void 0;
+  try {
+    for (var _iterator22 = ast.body[Symbol.iterator](), _step22; !(_iteratorNormalCompletion22 = (_step22 = _iterator22.next()).done); _iteratorNormalCompletion22 = true) {
+      var stmt5 = _step22.value;
+      if (stmt5.type !== "ImportDeclaration") continue;
+      if (stmt5.importKind === "type") continue;
+      if (!stmt5.specifiers || stmt5.specifiers.length === 0) continue;
+      var kept = stmt5.specifiers.filter(function (sp2) {
+        if (sp2.importKind === "type") return true;
+        return !exclusiveServerBindings.has(sp2.local.name);
+      });
+      if (kept.length === 0) {
+        var end3 = stmt5.end;
+        if (code[end3] === ";") end3++;
+        if (code[end3] === "\r" && code[end3 + 1] === "\n") end3 += 2;else if (code[end3] === "\n") end3 += 1;
+        s.remove(stmt5.start, end3);
+      } else if (kept.length < stmt5.specifiers.length) {
+        var declCode = code.slice(stmt5.start, stmt5.source.start);
+        var prefixMatch = declCode.match(/^import\s+/);
+        var prefixEnd = stmt5.start + (prefixMatch ? prefixMatch[0].length : 7);
+        var pos = stmt5.source.start - 1;
+        while (pos >= 0 && /\s/.test(code[pos])) pos--;
+        var fromStart = pos - 3;
+        var defaultSpec = kept.find(function (sp2) {
+          return sp2.type === "ImportDefaultSpecifier";
+        });
+        var namespaceSpec = kept.find(function (sp2) {
+          return sp2.type === "ImportNamespaceSpecifier";
+        });
+        var namedSpecs = kept.filter(function (sp2) {
+          return sp2.type === "ImportSpecifier";
+        });
+        var parts = [];
+        if (defaultSpec) parts.push(defaultSpec.local.name);
+        if (namespaceSpec) parts.push("* as " + namespaceSpec.local.name);
+        if (namedSpecs.length > 0) {
+          var namedStr = namedSpecs.map(function (sp2) {
+            var typePrefix = sp2.importKind === "type" ? "type " : "";
+            var importedName = sp2.imported.raw || sp2.imported.name;
+            if (importedName === sp2.local.name) {
+              return typePrefix + sp2.local.name;
+            }
+            return typePrefix + importedName + " as " + sp2.local.name;
+          }).join(", ");
+          parts.push("{ " + namedStr + " }");
+        }
+        s.overwrite(prefixEnd, fromStart, parts.join(", ") + " ");
+      }
+    }
+  } catch (err) {
+    _didIteratorError22 = true;
+    _iteratorError22 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion22 && _iterator22.return != null) {
+        _iterator22.return();
+      }
+    } finally {
+      if (_didIteratorError22) {
+        throw _iteratorError22;
+      }
+    }
+  }
+  console.info(` \u{1F9F9} [one]      ${relative(process.cwd(), id)} removed ${removedFunctions.length} server-only exports`);
+  return {
+    code: s.toString(),
+    map: s.generateMap({
+      hires: "boundary",
+      source: id,
+      includeContent: true
+    })
+  };
 }
 export { clientTreeShakePlugin, transformTreeShakeClient };
 //# sourceMappingURL=clientTreeShakePlugin.native.js.map