Make the VersionUnion class public.

lib/src/version_constraint.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'patterns.dart';
 import 'version.dart';
 import 'version_range.dart';
 import 'version_union.dart';
+import 'utils.dart';
 
 /// A [VersionConstraint] is a predicate that can determine whether a given
 /// version is valid or not.
 ///
 /// For example, a ">= 2.0.0" constraint allows any version that is "2.0.0" or
 /// greater. Version objects themselves implement this to match a specific
 /// version.
 abstract class VersionConstraint {
   /// A [VersionConstraint] that allows all versions.
   static VersionConstraint any = new VersionRange();
@@ skipping 146 matching lines @@
       constraint = constraint.intersect(other);
     }
     return constraint;
   }
 
   /// Creates a new version constraint that is the union of [constraints].
   ///
   /// It allows any versions that any of those constraints allows. If
   /// [constraints] is empty, this returns a constraint that allows no versions.
   factory VersionConstraint.unionOf(
-          Iterable<VersionConstraint> constraints) =>
-      VersionUnion.create(constraints);
+          Iterable<VersionConstraint> constraints) {
+    var flattened = constraints.expand((constraint) {
+      if (constraint.isEmpty) return [];
+      if (constraint is VersionUnion) return constraint.ranges;
+      return [constraint];
+    }).toList();
+
+    if (flattened.isEmpty) return VersionConstraint.empty;
+
+    if (flattened.any((constraint) => constraint.isAny)) {
+      return VersionConstraint.any;
+    }
+
+    // Only allow Versions and VersionRanges here so we can more easily reason
+    // about everything in [flattened]. _EmptyVersions and VersionUnions are
+    // filtered out above.
+    for (var constraint in flattened) {
+      if (constraint is VersionRange) continue;
+      throw new ArgumentError('Unknown VersionConstraint type $constraint.');
+    }
+
+    flattened.sort(compareMax);
+
+    var merged = <VersionRange>[];
+    for (var constraint in flattened) {
+      // Merge this constraint with the previous one, but only if they touch.
+      if (merged.isEmpty ||
+          (!merged.last.allowsAny(constraint) &&
+              !areAdjacent(merged.last, constraint))) {
+        merged.add(constraint);
+      } else {
+        merged[merged.length - 1] = merged.last.union(constraint);
+      }
+    }
+
+    if (merged.length == 1) return merged.single;
+    return new VersionUnion.fromRanges(merged);
+  }
 
   /// Returns `true` if this constraint allows no versions.
   bool get isEmpty;
 
   /// Returns `true` if this constraint allows all versions.
   bool get isAny;
 
   /// Returns `true` if this constraint allows [version].
   bool allows(Version version);
 
@@ skipping 27 matching lines @@
   String toString() => '<empty>';
 }
 
 class _CompatibleWithVersionRange extends VersionRange {
   _CompatibleWithVersionRange(Version version) : super(
       min: version, includeMin: true,
       max: version.nextBreaking, includeMax: false);
 
   String toString() => '^$min';
 }