sjfloat
diff --git a/‎dist/immutable.d.ts
Copy file name to clipboardExpand all lines: dist/immutable.d.ts
+15-13Lines changed: 15 additions & 13 deletions b/‎dist/immutable.d.ts
Copy file name to clipboardExpand all lines: dist/immutable.d.ts
+15-13Lines changed: 15 additions & 13 deletions
diff --git a/‎dist/immutable.js
Copy file name to clipboardExpand all lines: dist/immutable.js
+18-14Lines changed: 18 additions & 14 deletions b/‎dist/immutable.js
Copy file name to clipboardExpand all lines: dist/immutable.js
+18-14Lines changed: 18 additions & 14 deletions
@@ -72,7 +72,7 @@ declare module 'immutable' {
 
   /**
    * Value equality check with semantics similar to `Object.is`, but treats
-   * Immutable `Iterable`s as values, equal if the second `Iterable` contains
+   * Immutable `Iterable`s as values, equal if the second `Iterable` includes
    * equivalent values.
    *
    * It's used throughout Immutable when checking for equality, including `Map`
@@ -454,7 +454,7 @@ declare module 'immutable' {
      * If any of the values provided to `merge` are not Iterable (would return
      * false for `Immutable.isIterable`) then they are deeply converted via
      * `Immutable.fromJS` before being merged. However, if the value is an
-     * Iterable but contains non-iterable JS objects or arrays, those nested
+     * Iterable but includes non-iterable JS objects or arrays, those nested
      * values will be preserved.
      *
      *     var x = Immutable.Map({a: 10, b: 20, c: 30});
@@ -1405,7 +1405,9 @@ declare module 'immutable' {
 
     /**
      * True if a value exists within this `Iterable`.
+     * @alias contains
      */
+    includes(value: V): boolean;
     contains(value: V): boolean;
 
     /**
@@ -1637,7 +1639,7 @@ declare module 'immutable' {
     reverse(): /*this*/Iterable<K, V>;
 
     /**
-     * Returns a new Iterable of the same type which contains the same entries,
+     * Returns a new Iterable of the same type which includes the same entries,
      * stably sorted by using a `comparator`.
      *
      * If a `comparator` is not provided, a default comparator uses `<` and `>`.
@@ -1739,7 +1741,7 @@ declare module 'immutable' {
     skipLast(amount: number): /*this*/Iterable<K, V>;
 
     /**
-     * Returns a new Iterable of the same type which contains entries starting
+     * Returns a new Iterable of the same type which includes entries starting
      * from when `predicate` first returns false.
      *
      *     Seq.of('dog','frog','cat','hat','god')
@@ -1753,7 +1755,7 @@ declare module 'immutable' {
     ): /*this*/Iterable<K, V>;
 
     /**
-     * Returns a new Iterable of the same type which contains entries starting
+     * Returns a new Iterable of the same type which includes entries starting
      * from when `predicate` first returns true.
      *
      *     Seq.of('dog','frog','cat','hat','god')
@@ -1767,19 +1769,19 @@ declare module 'immutable' {
     ): /*this*/Iterable<K, V>;
 
     /**
-     * Returns a new Iterable of the same type which contains the first `amount`
+     * Returns a new Iterable of the same type which includes the first `amount`
      * entries from this Iterable.
      */
     take(amount: number): /*this*/Iterable<K, V>;
 
     /**
-     * Returns a new Iterable of the same type which contains the last `amount`
+     * Returns a new Iterable of the same type which includes the last `amount`
      * entries from this Iterable.
      */
     takeLast(amount: number): /*this*/Iterable<K, V>;
 
     /**
-     * Returns a new Iterable of the same type which contains entries from this
+     * Returns a new Iterable of the same type which includes entries from this
      * Iterable as long as the `predicate` returns true.
      *
      *     Seq.of('dog','frog','cat','hat','god')
@@ -1793,7 +1795,7 @@ declare module 'immutable' {
     ): /*this*/Iterable<K, V>;
 
     /**
-     * Returns a new Iterable of the same type which contains entries from this
+     * Returns a new Iterable of the same type which includes entries from this
      * Iterable as long as the `predicate` returns false.
      *
      *     Seq.of('dog','frog','cat','hat','god').takeUntil(x => x.match(/at/))
@@ -1900,7 +1902,7 @@ declare module 'immutable' {
     join(separator?: string): string;
 
     /**
-     * Returns true if this Iterable contains no values.
+     * Returns true if this Iterable includes no values.
      *
      * For some lazy `Seq`, `isEmpty` might need to iterate to determine
      * emptiness. At most one iteration will occur.
@@ -2040,13 +2042,13 @@ declare module 'immutable' {
     // Comparison
 
     /**
-     * True if `iter` contains every value in this Iterable.
+     * True if `iter` includes every value in this Iterable.
      */
     isSubset(iter: Iterable<any, V>): boolean;
     isSubset(iter: Array<V>): boolean;
 
     /**
-     * True if this Iterable contains every value in `iter`.
+     * True if this Iterable includes every value in `iter`.
      */
     isSuperset(iter: Iterable<any, V>): boolean;
     isSuperset(iter: Array<V>): boolean;
@@ -2239,7 +2241,7 @@ declare module 'immutable' {
      * Returns an Iterable of the same type with the provided `iterables`
      * interleaved into this iterable.
      *
-     * The resulting Iterable contains the first item from each, then the
+     * The resulting Iterable includes the first item from each, then the
      * second from each, etc.
      *
      *     I.Seq.of(1,2,3).interleave(I.Seq.of('A','B','C'))
 
@@ -1007,8 +1007,8 @@
       this.size = iter.size;
     }
 
-    ToIndexedSequence.prototype.contains = function(value) {
-      return this._iter.contains(value);
+    ToIndexedSequence.prototype.includes = function(value) {
+      return this._iter.includes(value);
     };
 
     ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
@@ -1035,7 +1035,7 @@
     }
 
     ToSetSequence.prototype.has = function(key) {
-      return this._iter.contains(key);
+      return this._iter.includes(key);
     };
 
     ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
@@ -1122,8 +1122,8 @@
       reversedSequence.flip = function()  {return iterable.reverse()};
       return reversedSequence;
     };
-    flipSequence.has = function(key ) {return iterable.contains(key)};
-    flipSequence.contains = function(key ) {return iterable.has(key)};
+    flipSequence.has = function(key ) {return iterable.includes(key)};
+    flipSequence.includes = function(key ) {return iterable.has(key)};
     flipSequence.cacheResult = cacheResultThrough;
     flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
       return iterable.__iterate(function(v, k)  {return fn(k, v, this$0) !== false}, reverse);
@@ -1203,7 +1203,7 @@
       {return iterable.get(useKeys ? key : -1 - key, notSetValue)};
     reversedSequence.has = function(key )
       {return iterable.has(useKeys ? key : -1 - key)};
-    reversedSequence.contains = function(value ) {return iterable.contains(value)};
+    reversedSequence.includes = function(value ) {return iterable.includes(value)};
     reversedSequence.cacheResult = cacheResultThrough;
     reversedSequence.__iterate = function (fn, reverse) {var this$0 = this;
       return iterable.__iterate(function(v, k)  {return fn(v, k, this$0)}, !reverse);
@@ -3577,7 +3577,7 @@
       var originalSet = this;
       return this.withMutations(function(set ) {
         originalSet.forEach(function(value ) {
-          if (!iters.every(function(iter ) {return iter.contains(value)})) {
+          if (!iters.every(function(iter ) {return iter.includes(value)})) {
             set.remove(value);
           }
         });
@@ -3592,7 +3592,7 @@
       var originalSet = this;
       return this.withMutations(function(set ) {
         originalSet.forEach(function(value ) {
-          if (iters.some(function(iter ) {return iter.contains(value)})) {
+          if (iters.some(function(iter ) {return iter.includes(value)})) {
             set.remove(value);
           }
         });
@@ -3995,7 +3995,7 @@
         notSetValue;
     };
 
-    Range.prototype.contains = function(searchValue) {
+    Range.prototype.includes = function(searchValue) {
       var possibleIndex = (searchValue - this._start) / this._step;
       return possibleIndex >= 0 &&
         possibleIndex < this.size &&
@@ -4092,7 +4092,7 @@
       return this.has(index) ? this._value : notSetValue;
     };
 
-    Repeat.prototype.contains = function(searchValue) {
+    Repeat.prototype.includes = function(searchValue) {
       return is(this._value, searchValue);
     };
 
@@ -4258,6 +4258,10 @@
     },
 
     contains: function(searchValue) {
+      return this.includes(searchValue);
+    },
+
+    includes: function(searchValue) {
       return this.some(function(value ) {return is(value, searchValue)});
     },
 
@@ -4464,8 +4468,8 @@
     },
 
     isSubset: function(iter) {
-      iter = typeof iter.contains === 'function' ? iter : Iterable(iter);
-      return this.every(function(value ) {return iter.contains(value)});
+      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);
+      return this.every(function(value ) {return iter.includes(value)});
     },
 
     isSuperset: function(iter) {
@@ -4783,7 +4787,7 @@
       return this.has(value) ? value : notSetValue;
     },
 
-    contains: function(value) {
+    includes: function(value) {
       return this.has(value);
     },
 
@@ -4796,7 +4800,7 @@
 
   });
 
-  SetIterable.prototype.has = IterablePrototype.contains;
+  SetIterable.prototype.has = IterablePrototype.includes;
 
 
   // Mixin subclasses