@angular/router 0.1.0 → 2.0.0-rc.2

package/esm/src/facade/async.js

@@ -0,0 +1,137 @@
+import { Subject } from 'rxjs/Subject';
+import { PromiseObservable } from 'rxjs/observable/PromiseObservable';
+import { toPromise } from 'rxjs/operator/toPromise';
+import { global, noop } from './lang';
+export { Observable } from 'rxjs/Observable';
+export { Subject } from 'rxjs/Subject';
+export { PromiseCompleter, PromiseWrapper } from './promise';
+export class TimerWrapper {
+    static setTimeout(fn, millis) {
+        return global.setTimeout(fn, millis);
+    }
+    static clearTimeout(id) { global.clearTimeout(id); }
+    static setInterval(fn, millis) {
+        return global.setInterval(fn, millis);
+    }
+    static clearInterval(id) { global.clearInterval(id); }
+}
+export class ObservableWrapper {
+    // TODO(vsavkin): when we use rxnext, try inferring the generic type from the first arg
+    static subscribe(emitter, onNext, onError, onComplete = () => { }) {
+        onError = (typeof onError === 'function') && onError || noop;
+        onComplete = (typeof onComplete === 'function') && onComplete || noop;
+        return emitter.subscribe({ next: onNext, error: onError, complete: onComplete });
+    }
+    static isObservable(obs) { return !!obs.subscribe; }
+    /**
+     * Returns whether `obs` has any subscribers listening to events.
+     */
+    static hasSubscribers(obs) { return obs.observers.length > 0; }
+    static dispose(subscription) { subscription.unsubscribe(); }
+    /**
+     * @deprecated - use callEmit() instead
+     */
+    static callNext(emitter, value) { emitter.next(value); }
+    static callEmit(emitter, value) { emitter.emit(value); }
+    static callError(emitter, error) { emitter.error(error); }
+    static callComplete(emitter) { emitter.complete(); }
+    static fromPromise(promise) {
+        return PromiseObservable.create(promise);
+    }
+    static toPromise(obj) { return toPromise.call(obj); }
+}
+/**
+ * Use by directives and components to emit custom Events.
+ *
+ * ### Examples
+ *
+ * In the following example, `Zippy` alternatively emits `open` and `close` events when its
+ * title gets clicked:
+ *
+ * ```
+ * @Component({
+ *   selector: 'zippy',
+ *   template: `
+ *   <div class="zippy">
+ *     <div (click)="toggle()">Toggle</div>
+ *     <div [hidden]="!visible">
+ *       <ng-content></ng-content>
+ *     </div>
+ *  </div>`})
+ * export class Zippy {
+ *   visible: boolean = true;
+ *   @Output() open: EventEmitter<any> = new EventEmitter();
+ *   @Output() close: EventEmitter<any> = new EventEmitter();
+ *
+ *   toggle() {
+ *     this.visible = !this.visible;
+ *     if (this.visible) {
+ *       this.open.emit(null);
+ *     } else {
+ *       this.close.emit(null);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The events payload can be accessed by the parameter `$event` on the components output event
+ * handler:
+ *
+ * ```
+ * <zippy (open)="onOpen($event)" (close)="onClose($event)"></zippy>
+ * ```
+ *
+ * Uses Rx.Observable but provides an adapter to make it work as specified here:
+ * https://github.com/jhusain/observable-spec
+ *
+ * Once a reference implementation of the spec is available, switch to it.
+ * @stable
+ */
+export class EventEmitter extends Subject {
+    /**
+     * Creates an instance of [EventEmitter], which depending on [isAsync],
+     * delivers events synchronously or asynchronously.
+     */
+    constructor(isAsync = false) {
+        super();
+        this.__isAsync = isAsync;
+    }
+    emit(value) { super.next(value); }
+    /**
+     * @deprecated - use .emit(value) instead
+     */
+    next(value) { super.next(value); }
+    subscribe(generatorOrNext, error, complete) {
+        let schedulerFn;
+        let errorFn = (err) => null;
+        let completeFn = () => null;
+        if (generatorOrNext && typeof generatorOrNext === 'object') {
+            schedulerFn = this.__isAsync ? (value /** TODO #9100 */) => {
+                setTimeout(() => generatorOrNext.next(value));
+            } : (value /** TODO #9100 */) => { generatorOrNext.next(value); };
+            if (generatorOrNext.error) {
+                errorFn = this.__isAsync ? (err) => { setTimeout(() => generatorOrNext.error(err)); } :
+                        (err) => { generatorOrNext.error(err); };
+            }
+            if (generatorOrNext.complete) {
+                completeFn = this.__isAsync ? () => { setTimeout(() => generatorOrNext.complete()); } :
+                        () => { generatorOrNext.complete(); };
+            }
+        }
+        else {
+            schedulerFn = this.__isAsync ? (value /** TODO #9100 */) => {
+                setTimeout(() => generatorOrNext(value));
+            } : (value /** TODO #9100 */) => { generatorOrNext(value); };
+            if (error) {
+                errorFn =
+                    this.__isAsync ? (err) => { setTimeout(() => error(err)); } : (err) => { error(err); };
+            }
+            if (complete) {
+                completeFn =
+                    this.__isAsync ? () => { setTimeout(() => complete()); } : () => { complete(); };
+            }
+        }
+        return super.subscribe(schedulerFn, errorFn, completeFn);
+    }
+}
+//# sourceMappingURL=async.js.map

package/esm/src/facade/async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","sourceRoot":"","sources":["../../../../../../modules/@angular/router/src/facade/async.ts"],"names":[],"mappings":"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","sourcesContent":["import {Observable} from 'rxjs/Observable';\nimport {Subject} from 'rxjs/Subject';\nimport {PromiseObservable} from 'rxjs/observable/PromiseObservable';\nimport {toPromise} from 'rxjs/operator/toPromise';\n\nimport {global, noop} from './lang';\n\nexport {Observable} from 'rxjs/Observable';\nexport {Subject} from 'rxjs/Subject';\nexport {PromiseCompleter, PromiseWrapper} from './promise';\n\nexport class TimerWrapper {\n  static setTimeout(fn: (...args: any[]) => void, millis: number): number {\n    return global.setTimeout(fn, millis);\n  }\n  static clearTimeout(id: number): void { global.clearTimeout(id); }\n\n  static setInterval(fn: (...args: any[]) => void, millis: number): number {\n    return global.setInterval(fn, millis);\n  }\n  static clearInterval(id: number): void { global.clearInterval(id); }\n}\n\nexport class ObservableWrapper {\n  // TODO(vsavkin): when we use rxnext, try inferring the generic type from the first arg\n  static subscribe<T>(\n      emitter: any, onNext: (value: T) => void, onError?: (exception: any) => void,\n      onComplete: () => void = () => {}): Object {\n    onError = (typeof onError === 'function') && onError || noop;\n    onComplete = (typeof onComplete === 'function') && onComplete || noop;\n    return emitter.subscribe({next: onNext, error: onError, complete: onComplete});\n  }\n\n  static isObservable(obs: any): boolean { return !!obs.subscribe; }\n\n  /**\n   * Returns whether `obs` has any subscribers listening to events.\n   */\n  static hasSubscribers(obs: EventEmitter<any>): boolean { return obs.observers.length > 0; }\n\n  static dispose(subscription: any) { subscription.unsubscribe(); }\n\n  /**\n   * @deprecated - use callEmit() instead\n   */\n  static callNext(emitter: EventEmitter<any>, value: any) { emitter.next(value); }\n\n  static callEmit(emitter: EventEmitter<any>, value: any) { emitter.emit(value); }\n\n  static callError(emitter: EventEmitter<any>, error: any) { emitter.error(error); }\n\n  static callComplete(emitter: EventEmitter<any>) { emitter.complete(); }\n\n  static fromPromise(promise: Promise<any>): Observable<any> {\n    return PromiseObservable.create(promise);\n  }\n\n  static toPromise(obj: Observable<any>): Promise<any> { return toPromise.call(obj); }\n}\n\n/**\n * Use by directives and components to emit custom Events.\n *\n * ### Examples\n *\n * In the following example, `Zippy` alternatively emits `open` and `close` events when its\n * title gets clicked:\n *\n * ```\n * @Component({\n *   selector: 'zippy',\n *   template: `\n *   <div class=\"zippy\">\n *     <div (click)=\"toggle()\">Toggle</div>\n *     <div [hidden]=\"!visible\">\n *       <ng-content></ng-content>\n *     </div>\n *  </div>`})\n * export class Zippy {\n *   visible: boolean = true;\n *   @Output() open: EventEmitter<any> = new EventEmitter();\n *   @Output() close: EventEmitter<any> = new EventEmitter();\n *\n *   toggle() {\n *     this.visible = !this.visible;\n *     if (this.visible) {\n *       this.open.emit(null);\n *     } else {\n *       this.close.emit(null);\n *     }\n *   }\n * }\n * ```\n *\n * The events payload can be accessed by the parameter `$event` on the components output event\n * handler:\n *\n * ```\n * <zippy (open)=\"onOpen($event)\" (close)=\"onClose($event)\"></zippy>\n * ```\n *\n * Uses Rx.Observable but provides an adapter to make it work as specified here:\n * https://github.com/jhusain/observable-spec\n *\n * Once a reference implementation of the spec is available, switch to it.\n * @stable\n */\nexport class EventEmitter<T> extends Subject<T> {\n  // TODO: mark this as internal once all the facades are gone\n  // we can't mark it as internal now because EventEmitter exported via @angular/core would not\n  // contain this property making it incompatible with all the code that uses EventEmitter via\n  // facades, which are local to the code and do not have this property stripped.\n  // tslint:disable-next-line\n  __isAsync: boolean;\n\n  /**\n   * Creates an instance of [EventEmitter], which depending on [isAsync],\n   * delivers events synchronously or asynchronously.\n   */\n  constructor(isAsync: boolean = false) {\n    super();\n    this.__isAsync = isAsync;\n  }\n\n  emit(value: T) { super.next(value); }\n\n  /**\n   * @deprecated - use .emit(value) instead\n   */\n  next(value: any) { super.next(value); }\n\n  subscribe(generatorOrNext?: any, error?: any, complete?: any): any {\n    let schedulerFn: any /** TODO #9100 */;\n    let errorFn = (err: any): any /** TODO #9100 */ => null;\n    let completeFn = (): any /** TODO #9100 */ => null;\n\n    if (generatorOrNext && typeof generatorOrNext === 'object') {\n      schedulerFn = this.__isAsync ? (value: any /** TODO #9100 */) => {\n        setTimeout(() => generatorOrNext.next(value));\n      } : (value: any /** TODO #9100 */) => { generatorOrNext.next(value); };\n\n      if (generatorOrNext.error) {\n        errorFn = this.__isAsync ? (err) => { setTimeout(() => generatorOrNext.error(err)); } :\n                                   (err) => { generatorOrNext.error(err); };\n      }\n\n      if (generatorOrNext.complete) {\n        completeFn = this.__isAsync ? () => { setTimeout(() => generatorOrNext.complete()); } :\n                                      () => { generatorOrNext.complete(); };\n      }\n    } else {\n      schedulerFn = this.__isAsync ? (value: any /** TODO #9100 */) => {\n        setTimeout(() => generatorOrNext(value));\n      } : (value: any /** TODO #9100 */) => { generatorOrNext(value); };\n\n      if (error) {\n        errorFn =\n            this.__isAsync ? (err) => { setTimeout(() => error(err)); } : (err) => { error(err); };\n      }\n\n      if (complete) {\n        completeFn =\n            this.__isAsync ? () => { setTimeout(() => complete()); } : () => { complete(); };\n      }\n    }\n\n    return super.subscribe(schedulerFn, errorFn, completeFn);\n  }\n}\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n"]}

package/esm/src/facade/base_wrapped_exception.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A base class for the WrappedException that can be used to identify
+ * a WrappedException from ExceptionHandler without adding circular
+ * dependency.
+ */
+export declare class BaseWrappedException extends Error {
+    constructor(message: string);
+    readonly wrapperMessage: string;
+    readonly wrapperStack: any;
+    readonly originalException: any;
+    readonly originalStack: any;
+    readonly context: any;
+    readonly message: string;
+}

package/esm/src/facade/base_wrapped_exception.js

@@ -0,0 +1,17 @@
+/**
+ * A base class for the WrappedException that can be used to identify
+ * a WrappedException from ExceptionHandler without adding circular
+ * dependency.
+ */
+export class BaseWrappedException extends Error {
+    constructor(message) {
+        super(message);
+    }
+    get wrapperMessage() { return ''; }
+    get wrapperStack() { return null; }
+    get originalException() { return null; }
+    get originalStack() { return null; }
+    get context() { return null; }
+    get message() { return ''; }
+}
+//# sourceMappingURL=base_wrapped_exception.js.map

package/esm/src/facade/base_wrapped_exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_wrapped_exception.js","sourceRoot":"","sources":["../../../../../../modules/@angular/router/src/facade/base_wrapped_exception.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,0CAA0C,KAAK;IAC7C,YAAY,OAAe;QAAI,MAAM,OAAO,CAAC,CAAC;IAAC,CAAC;IAEhD,IAAI,cAAc,KAAa,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,IAAI,YAAY,KAAU,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IACxC,IAAI,iBAAiB,KAAU,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,IAAI,aAAa,KAAU,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IACzC,IAAI,OAAO,KAAU,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IACnC,IAAI,OAAO,KAAa,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;AACtC,CAAC;AAAA","sourcesContent":["/**\n * A base class for the WrappedException that can be used to identify\n * a WrappedException from ExceptionHandler without adding circular\n * dependency.\n */\nexport class BaseWrappedException extends Error {\n  constructor(message: string) { super(message); }\n\n  get wrapperMessage(): string { return ''; }\n  get wrapperStack(): any { return null; }\n  get originalException(): any { return null; }\n  get originalStack(): any { return null; }\n  get context(): any { return null; }\n  get message(): string { return ''; }\n}\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n"]}

package/esm/src/facade/collection.d.ts

@@ -0,0 +1,103 @@
+export declare var Map: MapConstructor;
+export declare var Set: SetConstructor;
+export declare class MapWrapper {
+    static clone<K, V>(m: Map<K, V>): Map<K, V>;
+    static createFromStringMap<T>(stringMap: {
+        [key: string]: T;
+    }): Map<string, T>;
+    static toStringMap<T>(m: Map<string, T>): {
+        [key: string]: T;
+    };
+    static createFromPairs(pairs: any[]): Map<any, any>;
+    static clearValues(m: Map<any, any>): void;
+    static iterable<T>(m: T): T;
+    static keys<K>(m: Map<K, any>): K[];
+    static values<V>(m: Map<any, V>): V[];
+}
+/**
+ * Wraps Javascript Objects
+ */
+export declare class StringMapWrapper {
+    static create(): {
+        [k: string]: any;
+    };
+    static contains(map: {
+        [key: string]: any;
+    }, key: string): boolean;
+    static get<V>(map: {
+        [key: string]: V;
+    }, key: string): V;
+    static set<V>(map: {
+        [key: string]: V;
+    }, key: string, value: V): void;
+    static keys(map: {
+        [key: string]: any;
+    }): string[];
+    static values<T>(map: {
+        [key: string]: T;
+    }): T[];
+    static isEmpty(map: {
+        [key: string]: any;
+    }): boolean;
+    static delete(map: {
+        [key: string]: any;
+    }, key: string): void;
+    static forEach<K, V>(map: {
+        [key: string]: V;
+    }, callback: Function): void;
+    static merge<V>(m1: {
+        [key: string]: V;
+    }, m2: {
+        [key: string]: V;
+    }): {
+        [key: string]: V;
+    };
+    static equals<V>(m1: {
+        [key: string]: V;
+    }, m2: {
+        [key: string]: V;
+    }): boolean;
+}
+/**
+ * A boolean-valued function over a value, possibly including context information
+ * regarding that value's position in an array.
+ */
+export interface Predicate<T> {
+    (value: T, index?: number, array?: T[]): boolean;
+}
+export declare class ListWrapper {
+    static createFixedSize(size: number): any[];
+    static createGrowableSize(size: number): any[];
+    static clone<T>(array: T[]): T[];
+    static forEachWithIndex<T>(array: T[], fn: (t: T, n: number) => void): void;
+    static first<T>(array: T[]): T;
+    static last<T>(array: T[]): T;
+    static indexOf<T>(array: T[], value: T, startIndex?: number): number;
+    static contains<T>(list: T[], el: T): boolean;
+    static reversed<T>(array: T[]): T[];
+    static concat(a: any[], b: any[]): any[];
+    static insert<T>(list: T[], index: number, value: T): void;
+    static removeAt<T>(list: T[], index: number): T;
+    static removeAll<T>(list: T[], items: T[]): void;
+    static remove<T>(list: T[], el: T): boolean;
+    static clear(list: any[]): void;
+    static isEmpty(list: any[]): boolean;
+    static fill(list: any[], value: any, start?: number, end?: number): void;
+    static equals(a: any[], b: any[]): boolean;
+    static slice<T>(l: T[], from?: number, to?: number): T[];
+    static splice<T>(l: T[], from: number, length: number): T[];
+    static sort<T>(l: T[], compareFn?: (a: T, b: T) => number): void;
+    static toString<T>(l: T[]): string;
+    static toJSON<T>(l: T[]): string;
+    static maximum<T>(list: T[], predicate: (t: T) => number): T;
+    static flatten<T>(list: Array<T | T[]>): T[];
+    static addAll<T>(list: Array<T>, source: Array<T>): void;
+}
+export declare function isListLikeIterable(obj: any): boolean;
+export declare function areIterablesEqual(a: any, b: any, comparator: Function): boolean;
+export declare function iterateListLike(obj: any, fn: Function): void;
+export declare class SetWrapper {
+    static createFromList<T>(lst: T[]): Set<T>;
+    static has<T>(s: Set<T>, key: T): boolean;
+    static delete<K>(m: Set<K>, k: K): void;
+}

package/esm/src/facade/collection.js

@@ -0,0 +1,343 @@
+import { getSymbolIterator, global, isArray, isBlank, isJsObject, isPresent } from './lang';
+export var Map = global.Map;
+export var Set = global.Set;
+// Safari and Internet Explorer do not support the iterable parameter to the
+// Map constructor.  We work around that by manually adding the items.
+var createMapFromPairs = (function () {
+    try {
+        if (new Map([[1, 2]]).size === 1) {
+            return function createMapFromPairs(pairs) { return new Map(pairs); };
+        }
+    }
+    catch (e) {
+    }
+    return function createMapAndPopulateFromPairs(pairs) {
+        var map = new Map();
+        for (var i = 0; i < pairs.length; i++) {
+            var pair = pairs[i];
+            map.set(pair[0], pair[1]);
+        }
+        return map;
+    };
+})();
+var createMapFromMap = (function () {
+    try {
+        if (new Map(new Map())) {
+            return function createMapFromMap(m) { return new Map(m); };
+        }
+    }
+    catch (e) {
+    }
+    return function createMapAndPopulateFromMap(m) {
+        var map = new Map();
+        m.forEach((v, k) => { map.set(k, v); });
+        return map;
+    };
+})();
+var _clearValues = (function () {
+    if ((new Map()).keys().next) {
+        return function _clearValues(m) {
+            var keyIterator = m.keys();
+            var k;
+            while (!((k = keyIterator.next()).done)) {
+                m.set(k.value, null);
+            }
+        };
+    }
+    else {
+        return function _clearValuesWithForeEach(m) {
+            m.forEach((v, k) => { m.set(k, null); });
+        };
+    }
+})();
+// Safari doesn't implement MapIterator.next(), which is used is Traceur's polyfill of Array.from
+// TODO(mlaval): remove the work around once we have a working polyfill of Array.from
+var _arrayFromMap = (function () {
+    try {
+        if ((new Map()).values().next) {
+            return function createArrayFromMap(m, getValues) {
+                return getValues ? Array.from(m.values()) : Array.from(m.keys());
+            };
+        }
+    }
+    catch (e) {
+    }
+    return function createArrayFromMapWithForeach(m, getValues) {
+        var res = ListWrapper.createFixedSize(m.size), i = 0;
+        m.forEach((v, k) => {
+            res[i] = getValues ? v : k;
+            i++;
+        });
+        return res;
+    };
+})();
+export class MapWrapper {
+    static clone(m) { return createMapFromMap(m); }
+    static createFromStringMap(stringMap) {
+        var result = new Map();
+        for (var prop in stringMap) {
+            result.set(prop, stringMap[prop]);
+        }
+        return result;
+    }
+    static toStringMap(m) {
+        var r = {};
+        m.forEach((v, k) => r[k] = v);
+        return r;
+    }
+    static createFromPairs(pairs) { return createMapFromPairs(pairs); }
+    static clearValues(m) { _clearValues(m); }
+    static iterable(m) { return m; }
+    static keys(m) { return _arrayFromMap(m, false); }
+    static values(m) { return _arrayFromMap(m, true); }
+}
+/**
+ * Wraps Javascript Objects
+ */
+export class StringMapWrapper {
+    static create() {
+        // Note: We are not using Object.create(null) here due to
+        // performance!
+        // http://jsperf.com/ng2-object-create-null
+        return {};
+    }
+    static contains(map, key) {
+        return map.hasOwnProperty(key);
+    }
+    static get(map, key) {
+        return map.hasOwnProperty(key) ? map[key] : undefined;
+    }
+    static set(map, key, value) { map[key] = value; }
+    static keys(map) { return Object.keys(map); }
+    static values(map) {
+        return Object.keys(map).reduce((r, a) => {
+            r.push(map[a]);
+            return r;
+        }, []);
+    }
+    static isEmpty(map) {
+        for (var prop in map) {
+            return false;
+        }
+        return true;
+    }
+    static delete(map, key) { delete map[key]; }
+    static forEach(map, callback) {
+        for (var prop in map) {
+            if (map.hasOwnProperty(prop)) {
+                callback(map[prop], prop);
+            }
+        }
+    }
+    static merge(m1, m2) {
+        var m = {};
+        for (var attr in m1) {
+            if (m1.hasOwnProperty(attr)) {
+                m[attr] = m1[attr];
+            }
+        }
+        for (var attr in m2) {
+            if (m2.hasOwnProperty(attr)) {
+                m[attr] = m2[attr];
+            }
+        }
+        return m;
+    }
+    static equals(m1, m2) {
+        var k1 = Object.keys(m1);
+        var k2 = Object.keys(m2);
+        if (k1.length != k2.length) {
+            return false;
+        }
+        var key;
+        for (var i = 0; i < k1.length; i++) {
+            key = k1[i];
+            if (m1[key] !== m2[key]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+export class ListWrapper {
+    // JS has no way to express a statically fixed size list, but dart does so we
+    // keep both methods.
+    static createFixedSize(size) { return new Array(size); }
+    static createGrowableSize(size) { return new Array(size); }
+    static clone(array) { return array.slice(0); }
+    static forEachWithIndex(array, fn) {
+        for (var i = 0; i < array.length; i++) {
+            fn(array[i], i);
+        }
+    }
+    static first(array) {
+        if (!array)
+            return null;
+        return array[0];
+    }
+    static last(array) {
+        if (!array || array.length == 0)
+            return null;
+        return array[array.length - 1];
+    }
+    static indexOf(array, value, startIndex = 0) {
+        return array.indexOf(value, startIndex);
+    }
+    static contains(list, el) { return list.indexOf(el) !== -1; }
+    static reversed(array) {
+        var a = ListWrapper.clone(array);
+        return a.reverse();
+    }
+    static concat(a, b) { return a.concat(b); }
+    static insert(list, index, value) { list.splice(index, 0, value); }
+    static removeAt(list, index) {
+        var res = list[index];
+        list.splice(index, 1);
+        return res;
+    }
+    static removeAll(list, items) {
+        for (var i = 0; i < items.length; ++i) {
+            var index = list.indexOf(items[i]);
+            list.splice(index, 1);
+        }
+    }
+    static remove(list, el) {
+        var index = list.indexOf(el);
+        if (index > -1) {
+            list.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    static clear(list) { list.length = 0; }
+    static isEmpty(list) { return list.length == 0; }
+    static fill(list, value, start = 0, end = null) {
+        list.fill(value, start, end === null ? list.length : end);
+    }
+    static equals(a, b) {
+        if (a.length != b.length)
+            return false;
+        for (var i = 0; i < a.length; ++i) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
+    }
+    static slice(l, from = 0, to = null) {
+        return l.slice(from, to === null ? undefined : to);
+    }
+    static splice(l, from, length) { return l.splice(from, length); }
+    static sort(l, compareFn) {
+        if (isPresent(compareFn)) {
+            l.sort(compareFn);
+        }
+        else {
+            l.sort();
+        }
+    }
+    static toString(l) { return l.toString(); }
+    static toJSON(l) { return JSON.stringify(l); }
+    static maximum(list, predicate) {
+        if (list.length == 0) {
+            return null;
+        }
+        var solution = null;
+        var maxValue = -Infinity;
+        for (var index = 0; index < list.length; index++) {
+            var candidate = list[index];
+            if (isBlank(candidate)) {
+                continue;
+            }
+            var candidateValue = predicate(candidate);
+            if (candidateValue > maxValue) {
+                solution = candidate;
+                maxValue = candidateValue;
+            }
+        }
+        return solution;
+    }
+    static flatten(list) {
+        var target = [];
+        _flattenArray(list, target);
+        return target;
+    }
+    static addAll(list, source) {
+        for (var i = 0; i < source.length; i++) {
+            list.push(source[i]);
+        }
+    }
+}
+function _flattenArray(source, target) {
+    if (isPresent(source)) {
+        for (var i = 0; i < source.length; i++) {
+            var item = source[i];
+            if (isArray(item)) {
+                _flattenArray(item, target);
+            }
+            else {
+                target.push(item);
+            }
+        }
+    }
+    return target;
+}
+export function isListLikeIterable(obj) {
+    if (!isJsObject(obj))
+        return false;
+    return isArray(obj) ||
+        (!(obj instanceof Map) &&
+            getSymbolIterator() in obj); // JS Iterable have a Symbol.iterator prop
+}
+export function areIterablesEqual(a, b, comparator) {
+    var iterator1 = a[getSymbolIterator()]();
+    var iterator2 = b[getSymbolIterator()]();
+    while (true) {
+        let item1 = iterator1.next();
+        let item2 = iterator2.next();
+        if (item1.done && item2.done)
+            return true;
+        if (item1.done || item2.done)
+            return false;
+        if (!comparator(item1.value, item2.value))
+            return false;
+    }
+}
+export function iterateListLike(obj, fn) {
+    if (isArray(obj)) {
+        for (var i = 0; i < obj.length; i++) {
+            fn(obj[i]);
+        }
+    }
+    else {
+        var iterator = obj[getSymbolIterator()]();
+        var item;
+        while (!((item = iterator.next()).done)) {
+            fn(item.value);
+        }
+    }
+}
+// Safari and Internet Explorer do not support the iterable parameter to the
+// Set constructor.  We work around that by manually adding the items.
+var createSetFromList = (function () {
+    var test = new Set([1, 2, 3]);
+    if (test.size === 3) {
+        return function createSetFromList(lst) { return new Set(lst); };
+    }
+    else {
+        return function createSetAndPopulateFromList(lst) {
+            var res = new Set(lst);
+            if (res.size !== lst.length) {
+                for (var i = 0; i < lst.length; i++) {
+                    res.add(lst[i]);
+                }
+            }
+            return res;
+        };
+    }
+})();
+export class SetWrapper {
+    static createFromList(lst) { return createSetFromList(lst); }
+    static has(s, key) { return s.has(key); }
+    static delete(m, k) { m.delete(k); }
+}
+//# sourceMappingURL=collection.js.map