diff --git a/compiler/src/import_path_expand.ts b/compiler/src/import_path_expand.ts
index 8a4c98582f519b180f906d945061df6e590eace9..63109115c634a13ef2a149f926faa7384059b33b 100644
--- a/compiler/src/import_path_expand.ts
+++ b/compiler/src/import_path_expand.ts
@@ -34,7 +34,8 @@ interface ImportInfo {
 interface SymbolInfo {
   filePath: string,
   isDefault: boolean,
-  skipTransform: boolean
+  skipTransform: boolean,
+  exportName?: string
 }
 
 interface SeparatedImportInfos {
@@ -121,7 +122,7 @@ function processDefaultImport(checker: ts.TypeChecker, importMap: Map<string, Im
     if (!resolved) {
       return;
     }
-    const { filePath, isDefault, skipTransform } = resolved;
+    const { filePath, isDefault, skipTransform, exportName } = resolved;
 
     const mapKey = skipTransform ? moduleSpecifier.text : filePath;
 
@@ -137,7 +138,9 @@ function processDefaultImport(checker: ts.TypeChecker, importMap: Map<string, Im
       // fallback: was re-exported as default, but originally named
       importMap.get(mapKey)!.namedImports.push(
         ts.factory.createImportSpecifier(importClause.isTypeOnly,
-          ts.factory.createIdentifier(importClause.name.text), importClause.name)
+          exportName && (exportName !== importClause.name.text) ?
+          ts.factory.createIdentifier(exportName) : ts.factory.createIdentifier(importClause.name.text),
+          importClause.name)
       );
     }
   }
@@ -152,7 +155,7 @@ function processNamedImport(checker: ts.TypeChecker, importMap: Map<string, Impo
       if (!resolved) {
         continue;
       }
-      const { filePath, isDefault, skipTransform } = resolved;
+      const { filePath, isDefault, skipTransform, exportName } = resolved;
       const mapKey = skipTransform ? moduleSpecifier.text : filePath;
 
       if (!importMap.has(mapKey)) {
@@ -165,7 +168,11 @@ function processNamedImport(checker: ts.TypeChecker, importMap: Map<string, Impo
         };
       } else {
         importMap.get(mapKey)!.namedImports.push(
-          ts.factory.createImportSpecifier(element.isTypeOnly, element.propertyName, element.name));
+          ts.factory.createImportSpecifier(element.isTypeOnly,
+            exportName && (exportName !== name) ?
+            ts.factory.createIdentifier(exportName) : element.propertyName,
+            element.name)
+        );
       }
     }
   }
@@ -237,8 +244,8 @@ function genModuleRequst(filePath: string, moduleRequest: string, modulePathMap:
 }
 
 function getRealFilePath(checker: ts.TypeChecker, moduleSpecifier: ts.StringLiteral,
-  exportName: string): SymbolInfo | undefined {
-  const symbol: ts.Symbol | undefined = resolveImportedSymbol(checker, moduleSpecifier, exportName);
+  importName: string): SymbolInfo | undefined {
+  const symbol: ts.Symbol | undefined = resolveImportedSymbol(checker, moduleSpecifier, importName);
   if (!symbol) {
     return undefined;
   }
@@ -247,16 +254,22 @@ function getRealFilePath(checker: ts.TypeChecker, moduleSpecifier: ts.StringLite
   if (!finalSymbol || !finalSymbol.declarations || finalSymbol.declarations.length === 0) {
     return {
       filePath: moduleSpecifier.text,
-      isDefault: exportName === 'default',
+      isDefault: importName === 'default',
       skipTransform: true
     };
   }
 
   const decl: ts.Declaration = finalSymbol.declarations?.[0];
   const filePath = path.normalize(decl.getSourceFile().fileName);
-  const isDefault: boolean = isActuallyDefaultExport(finalSymbol);
-
-  return { filePath, isDefault, skipTransform: false };
+  const [isDefault, exportName] = getDefaultExportName(finalSymbol);
+  if (!isDefault && !exportName) {
+    return {
+      filePath: moduleSpecifier.text,
+      isDefault: importName === 'default',
+      skipTransform: true
+    };
+  }
+  return { filePath, isDefault, skipTransform: false, exportName };
 }
 
 function resolveImportedSymbol(checker: ts.TypeChecker, moduleSpecifier: ts.StringLiteral,
@@ -313,51 +326,44 @@ function resolveAliasedSymbol(symbol: ts.Symbol, checker: ts.TypeChecker): ts.Sy
   return finalSymbol;
 }
 
-function isActuallyDefaultExport(symbol: ts.Symbol): boolean {
+function getDefaultExportName(symbol: ts.Symbol): [boolean, string] {
   const decl = symbol.valueDeclaration ?? symbol.declarations?.[0];
   if (!decl) {
-    return false;
+    return [false, ''];
+  }
+  if (ts.isVariableDeclaration(decl)) {
+    const parent = decl.parent?.parent;
+    if (ts.isVariableStatement(parent) && parent.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+      return [false, symbol.name];
+    }
   }
   const sourceFile = decl.getSourceFile();
   for (const stmt of sourceFile.statements) {
-    if (isDefaultExportAssignment(stmt, symbol)) {
-      return true;
-    }
-    if (isNamedDefaultExport(stmt, symbol)) {
-      return true;
-    }
-    if (isNamedDefaultDecl(stmt, decl, symbol)) {
-      return true;
+    if (ts.isExportAssignment(stmt) && !stmt.isExportEquals && ts.isIdentifier(stmt.expression) && stmt.expression.text === symbol.name) {
+      return [true, 'default'];
     }
-  }
-  return false;
-}
-
-function isDefaultExportAssignment(stmt: ts.Statement, symbol: ts.Symbol): boolean {
-  return ts.isExportAssignment(stmt) &&
-         !stmt.isExportEquals &&
-         ts.isIdentifier(stmt.expression) &&
-         stmt.expression.text === symbol.name;
-}
-
-function isNamedDefaultExport(stmt: ts.Statement, symbol: ts.Symbol): boolean {
-  if (!ts.isExportDeclaration(stmt) || !stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) {
-    return false;
-  }
-  for (const specifier of stmt.exportClause.elements) {
-    if (specifier.name.text === 'default' && specifier.propertyName?.text === symbol.name) {
-      return true;
+    if (ts.isExportDeclaration(stmt) && stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+      for (const specifier of stmt.exportClause.elements) {
+        if (specifier.name.text === 'default' && specifier.propertyName?.text === symbol.name) {
+          return [true, 'default'];
+        }
+        if (specifier.name.text === 'default' && !specifier.propertyName) {
+          return [false, ''];
+        }
+        if (specifier.name.text !== 'default' && specifier.propertyName?.text === symbol.name) {
+          return [false, specifier.name.text];
+        }
+        if (specifier.name.text !== 'default' && specifier.name.text === symbol.name) {
+          return [false, symbol.name];
+        }
+      }
     }
-    if (specifier.name.text === 'default' && !specifier.propertyName) {
-      return false;
+    if (stmt.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) && stmt.name?.text === decl.name?.getText()) {
+      if (stmt.modifiers?.some(m => m.kind === ts.SyntaxKind.DefaultKeyword)) {
+        return [true, 'default'];
+      }
+      return [false, stmt.name?.text];
     }
   }
-  return false;
-}
-
-function isNamedDefaultDecl(stmt: ts.Statement, decl: ts.Declaration, symbol: ts.Symbol): boolean {
-  return symbol.name === 'default' &&
-         (ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt)) &&
-         stmt.modifiers?.some(m => m.kind === ts.SyntaxKind.DefaultKeyword) &&
-         stmt.name?.text === decl.name?.getText();
+  return [false, ''];
 }
\ No newline at end of file