anchor.diff:     * List of public namespaces corresponding to each entry in [dependencies].
      */
     final List<_Namespace> dependencyToPublicNamespace = <_Namespace>[];
  +
  +  /**
  +   * Map from absolute URI of a library to its export namespace.
  +   */
  +  final Map<String, _ExportNamespace> exportNamespaces = {};
   
     _Prelinker(this.definingUnitUri, this.definingUnit, this.getPart,
         this.getImport, this.getDeclaredVariable) {
  
positive.code:   }
  
    /**
     * Wrapper around [getImport] that caches the return value in [importCache].
     */
    UnlinkedPublicNamespace getImportCached(String absoluteUri) {
  
negative.code:    * information from the library and the transitive closure of its exports.
     */
    _Namespace computeExportNamespace(String absoluteUri) {
      int firstCycleIdOfLastCall = 0;
      _Namespace chaseExports(String absoluteUri) {
        _ExportNamespace exportNamespace = getExportNamespace(absoluteUri);
  
        // If the export namespace is ready, return it.
        if (exportNamespace.isFull) {
          firstCycleIdOfLastCall = 0;
          return exportNamespace.namespace;
        }
  
        // If we are computing the export namespace for this library, and we
        // reached here, then we found a cycle.
        if (exportNamespace.id != 0) {
          firstCycleIdOfLastCall = exportNamespace.id;
          return null;
        }
  
        // Give each library a unique identifier.
        exportNamespace.id = _ExportNamespace.nextId++;
  
        // Append from exports.
        int firstCycleId = 0;
        UnlinkedPublicNamespace publicNamespace = getImportCached(absoluteUri);
        if (publicNamespace != null) {
          for (UnlinkedExportPublic export in publicNamespace.exports) {
            String unlinkedExportUri =
                _selectUri(export.uri, export.configurations);
            String exportUri = resolveUri(absoluteUri, unlinkedExportUri);
            if (exportUri != null) {
              NameFilter filter =
                  new NameFilter.forUnlinkedCombinators(export.combinators);
              _Namespace exported = chaseExports(exportUri);
              exported?.forEach((String name, _Meaning meaning) {
                if (filter.accepts(name) &&
                    !exportNamespace.namespace.definesLibraryName(name)) {
                  exportNamespace.namespace.add(name, meaning);
                }
              });
              if (firstCycleIdOfLastCall != 0) {
                if (firstCycleId == 0 || firstCycleId > firstCycleIdOfLastCall) {
                  firstCycleId = firstCycleIdOfLastCall;
                }
              }
            }
          }
        }
  
        // If this library is the first component of the cycle, then we are at
        // the beginning of this cycle, and combination of partial export
        // namespaces of other exported libraries and declarations of this
        // library is the full export namespace of this library.
        if (firstCycleId != 0 && firstCycleId == exportNamespace.id) {
          firstCycleId = 0;
        }
  
        // We're done with this library, successfully or not.
        exportNamespace.id = 0;
  
        // If no cycle detected in exports, mark the export namespace as full.
        if (firstCycleId == 0) {
          exportNamespace.isFull = true;
        }
  
        // Return the full or partial result.
        firstCycleIdOfLastCall = firstCycleId;
        return exportNamespace.namespace;
      }
  
      _ExportNamespace.nextId = 1;
      return chaseExports(absoluteUri);
    }
  
    /**
  