fix(internals): export internal modules as default, which plays nicer…

… with closure compiler

src/Ix.internal.ts

@@ -1,5 +1,5 @@
-import * as iterableX from './iterable/__modules';
-import * as asynciterableX from './asynciterable/__modules';
+import iterableX from './iterable/__modules';
+import asynciterableX from './asynciterable/__modules';
 export { iterableX as iterable, asynciterableX as asynciterable };
 
 /* These declarations are needed for the closure/umd targets */

src/asynciterable/__modules.ts

@@ -1,93 +1,223 @@
-export { average } from './average';
-export { buffer } from './buffer';
-export { _case } from './case';
-export { _catch, _catchStatic } from './catch';
-export { catchWith } from './catchwith';
-export { chain } from './chain';
-export { concat, concatAll, concatStatic } from './concat';
-export { count } from './count';
-export { create } from './create';
-export { debounce } from './debounce';
-export { defaultIfEmpty } from './defaultifempty';
-export { defer } from './defer';
-export { distinct } from './distinct';
-export { distinctUntilChanged } from './distinctuntilchanged';
-export { doWhile } from './dowhile';
-export { elementAt } from './elementat';
-export { empty } from './empty';
-export { every } from './every';
-export { except } from './except';
-export { expand } from './expand';
-export { filter } from './filter';
-export { _finally } from './finally';
-export { find } from './find';
-export { findIndex } from './findindex';
-export { first } from './first';
-export { flatMap } from './flatmap';
-export { flatten } from './flatten';
-export { _for } from './for';
-export { forEach } from './foreach';
-export { from } from './from';
-export { fromEvent } from './fromevent';
-export { fromEventPattern } from './fromeventpattern';
-export { generate } from './generate';
-export { generateTime } from './generatetime';
-export { groupBy } from './groupby';
-export { groupJoin } from './groupjoin';
-export { _if } from './if';
-export { ignoreElements } from './ignoreelements';
-export { includes } from './includes';
-export { innerJoin } from './innerjoin';
-export { intersect } from './intersect';
-export { isEmpty } from './isempty';
-export { last } from './last';
-export { map } from './map';
-export { max } from './max';
-export { maxBy } from './maxby';
-export { memoize } from './memoize';
-export { min } from './min';
-export { minBy } from './minby';
-export { of } from './of';
-export { ofEntries } from './ofentries';
-export { ofKeys } from './ofkeys';
-export { ofValues } from './ofvalues';
-export { onErrorResumeNext, onErrorResumeNextStatic } from './onerrorresumenext';
-export { orderBy, orderByDescending, thenBy, thenByDescending } from './orderby';
-export { pairwise } from './pairwise';
-export { partition } from './partition';
-export { pluck } from './pluck';
-export { publish } from './publish';
-export { race } from './race';
-export { range } from './range';
-export { reduce } from './reduce';
-export { reduceRight } from './reduceright';
-export { repeat, repeatStatic } from './repeat';
-export { retry } from './retry';
-export { reverse } from './reverse';
-export { scan } from './scan';
-export { scanRight } from './scanright';
-export { sequenceEqual } from './sequenceequal';
-export { share } from './share';
-export { single } from './single';
-export { skip } from './skip';
-export { skipLast } from './skiplast';
-export { skipUntil } from './skipuntil';
-export { skipWhile } from './skipwhile';
-export { slice } from './slice';
-export { some } from './some';
-export { startWith } from './startwith';
-export { sum } from './sum';
-export { take } from './take';
-export { takeLast } from './takelast';
-export { takeUntil } from './takeuntil';
-export { takeWhile } from './takewhile';
-export { tap } from './tap';
-export { throttle } from './throttle';
-export { _throw } from './throw';
-export { toArray } from './toarray';
-export { toMap } from './tomap';
-export { toObservable } from './toobservable';
-export { toSet } from './toset';
-export { union } from './union';
-export { _while } from './while';
-export { zip } from './zip';
+import { Observable } from '../observer';
+import { NextAsyncObserver } from '../observer';
+import { ErrorAsyncObserver } from '../observer';
+import { CompletionAsyncObserver } from '../observer';
+import { AsyncIterableX } from '../asynciterable';
+import { GroupedAsyncIterable } from './groupby';
+import { OrderedAsyncIterableX } from './orderby';
+import { OrderedAsyncIterableBaseX } from './orderby';
+
+import { average } from './average';
+import { buffer } from './buffer';
+import { _case } from './case';
+import { _catch } from './catch';
+import { _catchStatic } from './catch';
+import { catchWith } from './catchwith';
+import { chain } from './chain';
+import { concat } from './concat';
+import { concatAll } from './concat';
+import { concatStatic } from './concat';
+import { count } from './count';
+import { create } from './create';
+import { debounce } from './debounce';
+import { defaultIfEmpty } from './defaultifempty';
+import { defer } from './defer';
+import { distinct } from './distinct';
+import { distinctUntilChanged } from './distinctuntilchanged';
+import { doWhile } from './dowhile';
+import { elementAt } from './elementat';
+import { empty } from './empty';
+import { every } from './every';
+import { except } from './except';
+import { expand } from './expand';
+import { filter } from './filter';
+import { _finally } from './finally';
+import { find } from './find';
+import { findIndex } from './findindex';
+import { first } from './first';
+import { flatMap } from './flatmap';
+import { flatten } from './flatten';
+import { _for } from './for';
+import { forEach } from './foreach';
+import { from } from './from';
+import { fromEvent } from './fromevent';
+import { fromEventPattern } from './fromeventpattern';
+import { generate } from './generate';
+import { generateTime } from './generatetime';
+import { groupBy } from './groupby';
+import { groupJoin } from './groupjoin';
+import { _if } from './if';
+import { ignoreElements } from './ignoreelements';
+import { includes } from './includes';
+import { innerJoin } from './innerjoin';
+import { intersect } from './intersect';
+import { isEmpty } from './isempty';
+import { last } from './last';
+import { map } from './map';
+import { max } from './max';
+import { maxBy } from './maxby';
+import { memoize } from './memoize';
+import { min } from './min';
+import { minBy } from './minby';
+import { of } from './of';
+import { ofEntries } from './ofentries';
+import { ofKeys } from './ofkeys';
+import { ofValues } from './ofvalues';
+import { onErrorResumeNext } from './onerrorresumenext';
+import { onErrorResumeNextStatic } from './onerrorresumenext';
+import { orderBy } from './orderby';
+import { orderByDescending } from './orderby';
+import { thenBy } from './orderby';
+import { thenByDescending } from './orderby';
+import { pairwise } from './pairwise';
+import { partition } from './partition';
+import { pluck } from './pluck';
+import { publish } from './publish';
+import { race } from './race';
+import { range } from './range';
+import { reduce } from './reduce';
+import { reduceRight } from './reduceright';
+import { repeat } from './repeat';
+import { repeatStatic } from './repeat';
+import { retry } from './retry';
+import { reverse } from './reverse';
+import { scan } from './scan';
+import { scanRight } from './scanright';
+import { sequenceEqual } from './sequenceequal';
+import { share } from './share';
+import { single } from './single';
+import { skip } from './skip';
+import { skipLast } from './skiplast';
+import { skipUntil } from './skipuntil';
+import { skipWhile } from './skipwhile';
+import { slice } from './slice';
+import { some } from './some';
+import { startWith } from './startwith';
+import { sum } from './sum';
+import { take } from './take';
+import { takeLast } from './takelast';
+import { takeUntil } from './takeuntil';
+import { takeWhile } from './takewhile';
+import { tap } from './tap';
+import { throttle } from './throttle';
+import { _throw } from './throw';
+import { toArray } from './toarray';
+import { toMap } from './tomap';
+import { toObservable } from './toobservable';
+import { toSet } from './toset';
+import { union } from './union';
+import { _while } from './while';
+import { zip } from './zip';
+
+export type AsyncIterableX<T> = AsyncIterableX<T>;
+export type Observable<T> = Observable<T>;
+export type NextAsyncObserver<T> = NextAsyncObserver<T>;
+export type ErrorAsyncObserver<T> = ErrorAsyncObserver<T>;
+export type CompletionAsyncObserver<T> = CompletionAsyncObserver<T>;
+export type GroupedAsyncIterable<TKey, TValue> = GroupedAsyncIterable<TKey, TValue>;
+export type OrderedAsyncIterableX<TKey, TSource> = OrderedAsyncIterableX<TKey, TSource>;
+export type OrderedAsyncIterableBaseX<TSource> = OrderedAsyncIterableBaseX<TSource>;
+
+export default {
+    average,
+    buffer,
+    _case,
+    _catch,
+    _catchStatic,
+    catchWith,
+    chain,
+    concat,
+    concatAll,
+    concatStatic,
+    count,
+    create,
+    debounce,
+    defaultIfEmpty,
+    defer,
+    distinct,
+    distinctUntilChanged,
+    doWhile,
+    elementAt,
+    empty,
+    every,
+    except,
+    expand,
+    filter,
+    _finally,
+    find,
+    findIndex,
+    first,
+    flatMap,
+    flatten,
+    _for,
+    forEach,
+    from,
+    fromEvent,
+    fromEventPattern,
+    generate,
+    generateTime,
+    groupBy,
+    groupJoin,
+    _if,
+    ignoreElements,
+    includes,
+    innerJoin,
+    intersect,
+    isEmpty,
+    last,
+    map,
+    max,
+    maxBy,
+    memoize,
+    min,
+    minBy,
+    of,
+    ofEntries,
+    ofKeys,
+    ofValues,
+    onErrorResumeNext,
+    onErrorResumeNextStatic,
+    orderBy,
+    orderByDescending,
+    thenBy,
+    thenByDescending,
+    pairwise,
+    partition,
+    pluck,
+    publish,
+    race,
+    range,
+    reduce,
+    reduceRight,
+    repeat,
+    repeatStatic,
+    retry,
+    reverse,
+    scan,
+    scanRight,
+    sequenceEqual,
+    share,
+    single,
+    skip,
+    skipLast,
+    skipUntil,
+    skipWhile,
+    slice,
+    some,
+    startWith,
+    sum,
+    take,
+    takeLast,
+    takeUntil,
+    takeWhile,
+    tap,
+    throttle,
+    _throw,
+    toArray,
+    toMap,
+    toObservable,
+    toSet,
+    union,
+    _while,
+    zip
+};