Merge branch 'master' of https://github.com/ReactiveX/IxJS

package.json

@@ -78,13 +78,12 @@
     "rxjs": "5.4.3",
     "shx": "0.2.2",
     "source-map-loader": "0.2.2",
-    "source-map-support": "0.5.0",
     "spawn-rx": "2.0.12",
     "tap-difflet": "0.7.0",
-    "tape": "4.8.0",
+    "tape-async": "2.3.0",
     "trash": "4.1.0",
     "ts-node": "3.3.0",
-    "tsickle": "0.24.1",
+    "tsickle": "0.23.3",
     "tslint": "5.7.0",
     "tsutils": "2.11.2",
     "typescript": "2.5.3",
@@ -113,5 +112,10 @@
     "experimentalProposal": {
       "asyncGenerators": true
     }
+  },
+  "greenkeeper": {
+    "ignore": [
+      "tsickle"
+    ]
   }
 }

spec/asynciterable-operators/average-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { average } = Ix.asynciterable;
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/buffer-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { buffer } = Ix.asynciterable;
 const { empty } = Ix.asynciterable;
 const { range } = Ix.asynciterable;

spec/asynciterable-operators/catch-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { _catch } = Ix.asynciterable;
 const { concat } = Ix.asynciterable;
 const { range } = Ix.asynciterable;

spec/asynciterable-operators/catchwith-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { catchWith } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { range } = Ix.asynciterable;

spec/asynciterable-operators/chain-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { chain } = Ix.asynciterable;
 import { noNext } from '../asynciterablehelpers';

spec/asynciterable-operators/concat-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { concat } = Ix.asynciterable;
 const { concatAll } = Ix.asynciterable;
 const { map } = Ix.asynciterable;

spec/asynciterable-operators/count-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { count } = Ix.asynciterable;
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/debounce-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { debounce } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';
 

spec/asynciterable-operators/defaultifempty-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { defaultIfEmpty } = Ix.asynciterable;
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/distinct-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { distinct } = Ix.asynciterable;
 const { range } = Ix.asynciterable;
 const { sequenceEqual } = Ix.asynciterable;

spec/asynciterable-operators/distinctuntilchanged-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { distinctUntilChanged } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { sequenceEqual } = Ix.asynciterable;

spec/asynciterable-operators/dowhile-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { defer } = Ix.asynciterable;
 const { doWhile } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/elementat-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { elementAt } = Ix.asynciterable;
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/endwith-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { range } = Ix.asynciterable;
 const { sequenceEqual } = Ix.asynciterable;
 const { endWith } = Ix.asynciterable;

spec/asynciterable-operators/every-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { every } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { _throw } = Ix.asynciterable;

spec/asynciterable-operators/except-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { except } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';

spec/asynciterable-operators/expand-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { expand } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { range } = Ix.asynciterable;

spec/asynciterable-operators/filter-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { filter } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/finally-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { _finally } = Ix.asynciterable;
 const { range } = Ix.asynciterable;
 const { _throw } = Ix.asynciterable;

spec/asynciterable-operators/first-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { first } = Ix.asynciterable;

spec/asynciterable-operators/flatmap-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { flatMap } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { range } = Ix.asynciterable;

spec/asynciterable-operators/flatten-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { flatten } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { toArray } = Ix.asynciterable;

spec/asynciterable-operators/groupby-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { from } = Ix.asynciterable;
 const { groupBy } = Ix.asynciterable;

spec/asynciterable-operators/groupjoin-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { groupJoin } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { reduce } = Ix.asynciterable;

spec/asynciterable-operators/ignoreelements.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { forEach } = Ix.asynciterable;
 const { ignoreElements } = Ix.asynciterable;
 const { range } = Ix.asynciterable;

spec/asynciterable-operators/includes-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { of } = Ix.asynciterable;
 const { includes } = Ix.asynciterable;
 

spec/asynciterable-operators/innerjoin-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { innerJoin } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { _throw } = Ix.asynciterable;

spec/asynciterable-operators/intersect-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { of } = Ix.asynciterable;
 const { intersect } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';

spec/asynciterable-operators/isempty-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { isEmpty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/last-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { last } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/max-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { max } = Ix.asynciterable;

spec/asynciterable-operators/maxby-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { maxBy } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/merge-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { merge } = Ix.asynciterable;
 const { mergeAll } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/min-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { min } = Ix.asynciterable;

spec/asynciterable-operators/minby-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { minBy } = Ix.asynciterable;
 const { of } = Ix.asynciterable;

spec/asynciterable-operators/onerrorresumenext-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { concat } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { onErrorResumeNext } = Ix.asynciterable;

spec/asynciterable-operators/orderby-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { of } = Ix.asynciterable;
 const { orderBy, orderByDescending, thenBy, thenByDescending } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';

spec/asynciterable-operators/pairwise-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { pairwise } = Ix.asynciterable;

spec/asynciterable-operators/partition-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { partition } = Ix.asynciterable;

spec/asynciterable-operators/pluck-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { of } = Ix.asynciterable;
 const { pluck } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';

spec/asynciterable-operators/reduce-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { reduce } = Ix.asynciterable;

spec/asynciterable-operators/reduceright-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { reduceRight } = Ix.asynciterable;

spec/asynciterable-operators/retry-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { concat } = Ix.asynciterable;
 const { range } = Ix.asynciterable;
 const { retry } = Ix.asynciterable;

spec/asynciterable-operators/reverse-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { reverse } = Ix.asynciterable;

spec/asynciterable-operators/scan-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { range } = Ix.asynciterable;
 const { scan } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';

spec/asynciterable-operators/scanright-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { range } = Ix.asynciterable;
 const { scanRight } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';

spec/asynciterable-operators/sequenceequal-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { sequenceEqual } = Ix.asynciterable;

spec/asynciterable-operators/single-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { of } = Ix.asynciterable;
 const { single } = Ix.asynciterable;

spec/asynciterable-operators/skip-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { of } = Ix.asynciterable;
 const { skip } = Ix.asynciterable;
 const { _throw } = Ix.asynciterable;

spec/asynciterable-operators/skiplast-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { empty } = Ix.asynciterable;
 const { range } = Ix.asynciterable;
 const { sequenceEqual } = Ix.asynciterable;

spec/asynciterable-operators/skipuntil-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { skipUntil } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';
 

spec/asynciterable-operators/skipwhile-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { of } = Ix.asynciterable;
 const { skipWhile } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';

spec/asynciterable-operators/slice-spec.ts

@@ -1,5 +1,5 @@
 import * as Ix from '../Ix';
-import * as test from 'tape';
+import * as test from 'tape-async';
 const { from } = Ix.asynciterable;
 const { slice } = Ix.asynciterable;
 import { hasNext, noNext } from '../asynciterablehelpers';