From 648bd6e9e0436ff2da6ade805688a0daa6ce4c52 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 4 Oct 2017 14:43:35 -0700 Subject: [PATCH] Skip more lib checks, improve test execution time a bit more (#18952) * Skip more lib checks, improve test execution time a bit more * Change complexRecursiveCollections to still check * Remove way more --- .../complexRecursiveCollections.errors.txt | 10 +- .../reference/complexRecursiveCollections.js | 538 ++ .../complexRecursiveCollections.symbols | 5340 ++++++++--------- .../complexRecursiveCollections.types | 4 +- .../compiler/complexRecursiveCollections.ts | 5 +- .../jsx/checkJsxChildrenProperty1.tsx | 1 + .../jsx/checkJsxChildrenProperty13.tsx | 1 + .../jsx/checkJsxChildrenProperty2.tsx | 1 + .../jsx/checkJsxChildrenProperty4.tsx | 1 + .../jsx/checkJsxChildrenProperty6.tsx | 1 + .../jsx/checkJsxChildrenProperty7.tsx | 1 + .../jsx/checkJsxChildrenProperty8.tsx | 1 + .../jsx/checkJsxChildrenProperty9.tsx | 1 + .../jsx/commentEmittingInPreserveJsx1.tsx | 1 + .../jsx/tsxAttributeResolution15.tsx | 1 + .../jsx/tsxAttributeResolution16.tsx | 1 + .../jsx/tsxDefaultAttributesResolution1.tsx | 1 + .../jsx/tsxDefaultAttributesResolution2.tsx | 1 + .../jsx/tsxDefaultAttributesResolution3.tsx | 1 + .../jsx/tsxGenericAttributesType1.tsx | 1 + .../jsx/tsxGenericAttributesType2.tsx | 1 + .../jsx/tsxGenericAttributesType3.tsx | 1 + .../jsx/tsxGenericAttributesType5.tsx | 1 + .../jsx/tsxGenericAttributesType6.tsx | 1 + .../jsx/tsxGenericAttributesType7.tsx | 1 + .../jsx/tsxGenericAttributesType8.tsx | 1 + .../jsx/tsxGenericAttributesType9.tsx | 1 + ...eactComponentWithDefaultTypeParameter1.tsx | 1 + ...eactComponentWithDefaultTypeParameter2.tsx | 1 + ...eactComponentWithDefaultTypeParameter3.tsx | 1 + .../jsx/tsxSpreadAttributesResolution1.tsx | 1 + .../jsx/tsxSpreadAttributesResolution10.tsx | 1 + .../jsx/tsxSpreadAttributesResolution11.tsx | 1 + .../jsx/tsxSpreadAttributesResolution12.tsx | 1 + .../jsx/tsxSpreadAttributesResolution13.tsx | 1 + .../jsx/tsxSpreadAttributesResolution14.tsx | 1 + .../jsx/tsxSpreadAttributesResolution15.tsx | 1 + .../jsx/tsxSpreadAttributesResolution16.tsx | 1 + .../jsx/tsxSpreadAttributesResolution2.tsx | 1 + .../jsx/tsxSpreadAttributesResolution4.tsx | 1 + .../jsx/tsxSpreadAttributesResolution5.tsx | 1 + .../jsx/tsxSpreadAttributesResolution6.tsx | 1 + .../jsx/tsxSpreadAttributesResolution7.tsx | 1 + .../jsx/tsxSpreadAttributesResolution8.tsx | 1 + .../jsx/tsxSpreadAttributesResolution9.tsx | 1 + ...tsxStatelessFunctionComponentOverload3.tsx | 1 + ...tsxStatelessFunctionComponentOverload4.tsx | 1 + ...tsxStatelessFunctionComponentOverload5.tsx | 1 + ...tionComponentWithDefaultTypeParameter1.tsx | 1 + ...tionComponentWithDefaultTypeParameter2.tsx | 1 + .../jsx/tsxStatelessFunctionComponents2.tsx | 1 + .../jsx/tsxStatelessFunctionComponents3.tsx | 1 + ...ssFunctionComponentsWithTypeArguments1.tsx | 1 + ...ssFunctionComponentsWithTypeArguments4.tsx | 1 + ...ssFunctionComponentsWithTypeArguments5.tsx | 1 + .../conformance/jsx/tsxUnionElementType1.tsx | 1 + .../conformance/jsx/tsxUnionElementType2.tsx | 1 + .../conformance/jsx/tsxUnionElementType3.tsx | 1 + .../conformance/jsx/tsxUnionElementType4.tsx | 1 + .../conformance/jsx/tsxUnionElementType5.tsx | 1 + .../conformance/jsx/tsxUnionElementType6.tsx | 1 + .../jsx/tsxUnionTypeComponent2.tsx | 1 + ...lyTypedStringLiteralsInJsxAttributes02.tsx | 1 + 63 files changed, 3276 insertions(+), 2679 deletions(-) create mode 100644 tests/baselines/reference/complexRecursiveCollections.js diff --git a/tests/baselines/reference/complexRecursiveCollections.errors.txt b/tests/baselines/reference/complexRecursiveCollections.errors.txt index 495fca2e651..aaed4f26360 100644 --- a/tests/baselines/reference/complexRecursiveCollections.errors.txt +++ b/tests/baselines/reference/complexRecursiveCollections.errors.txt @@ -1,18 +1,18 @@ -tests/cases/compiler/immutable.d.ts(341,22): error TS2430: Interface 'Keyed' incorrectly extends interface 'Collection'. +tests/cases/compiler/immutable.ts(341,22): error TS2430: Interface 'Keyed' incorrectly extends interface 'Collection'. Types of property 'toSeq' are incompatible. Type '() => Keyed' is not assignable to type '() => this'. Type 'Keyed' is not assignable to type 'this'. -tests/cases/compiler/immutable.d.ts(359,22): error TS2430: Interface 'Indexed' incorrectly extends interface 'Collection'. +tests/cases/compiler/immutable.ts(359,22): error TS2430: Interface 'Indexed' incorrectly extends interface 'Collection'. Types of property 'toSeq' are incompatible. Type '() => Indexed' is not assignable to type '() => this'. Type 'Indexed' is not assignable to type 'this'. -tests/cases/compiler/immutable.d.ts(391,22): error TS2430: Interface 'Set' incorrectly extends interface 'Collection'. +tests/cases/compiler/immutable.ts(391,22): error TS2430: Interface 'Set' incorrectly extends interface 'Collection'. Types of property 'toSeq' are incompatible. Type '() => Set' is not assignable to type '() => this'. Type 'Set' is not assignable to type 'this'. -==== tests/cases/compiler/complex.d.ts (0 errors) ==== +==== tests/cases/compiler/complex.ts (0 errors) ==== interface Ara { t: T } interface Collection { map(mapper: (value: V, key: K, iter: this) => M): Collection; @@ -33,7 +33,7 @@ tests/cases/compiler/immutable.d.ts(391,22): error TS2430: Interface 'Set' in flatMap(mapper: (value: T, key: void, iter: this) => Ara, context?: any): N2; toSeq(): N2; } -==== tests/cases/compiler/immutable.d.ts (3 errors) ==== +==== tests/cases/compiler/immutable.ts (3 errors) ==== // Test that complex recursive collections can pass the `extends` assignability check without // running out of memory. This bug was exposed in Typescript 2.4 when more generic signatures // started being checked. diff --git a/tests/baselines/reference/complexRecursiveCollections.js b/tests/baselines/reference/complexRecursiveCollections.js new file mode 100644 index 00000000000..21b371b7d3b --- /dev/null +++ b/tests/baselines/reference/complexRecursiveCollections.js @@ -0,0 +1,538 @@ +//// [tests/cases/compiler/complexRecursiveCollections.ts] //// + +//// [complex.ts] +interface Ara { t: T } +interface Collection { + map(mapper: (value: V, key: K, iter: this) => M): Collection; + flatMap(mapper: (value: V, key: K, iter: this) => Ara, context?: any): Collection; + // these seem necessary to push it over the top for memory usage + reduce(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R; + reduce(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; + toSeq(): Seq; +} +interface Seq extends Collection { +} +interface N1 extends Collection { + map(mapper: (value: T, key: void, iter: this) => M): N1; + flatMap(mapper: (value: T, key: void, iter: this) => Ara, context?: any): N1; +} +interface N2 extends N1 { + map(mapper: (value: T, key: void, iter: this) => M): N2; + flatMap(mapper: (value: T, key: void, iter: this) => Ara, context?: any): N2; + toSeq(): N2; +} +//// [immutable.ts] +// Test that complex recursive collections can pass the `extends` assignability check without +// running out of memory. This bug was exposed in Typescript 2.4 when more generic signatures +// started being checked. +declare module Immutable { + export function fromJS(jsValue: any, reviver?: (key: string | number, sequence: Collection.Keyed | Collection.Indexed, path?: Array) => any): any; + export function is(first: any, second: any): boolean; + export function hash(value: any): number; + export function isImmutable(maybeImmutable: any): maybeImmutable is Collection; + export function isCollection(maybeCollection: any): maybeCollection is Collection; + export function isKeyed(maybeKeyed: any): maybeKeyed is Collection.Keyed; + export function isIndexed(maybeIndexed: any): maybeIndexed is Collection.Indexed; + export function isAssociative(maybeAssociative: any): maybeAssociative is Collection.Keyed | Collection.Indexed; + export function isOrdered(maybeOrdered: any): boolean; + export function isValueObject(maybeValue: any): maybeValue is ValueObject; + export interface ValueObject { + equals(other: any): boolean; + hashCode(): number; + } + export module List { + function isList(maybeList: any): maybeList is List; + function of(...values: Array): List; + } + export function List(): List; + export function List(): List; + export function List(collection: Iterable): List; + export interface List extends Collection.Indexed { + // Persistent changes + set(index: number, value: T): List; + delete(index: number): List; + remove(index: number): List; + insert(index: number, value: T): List; + clear(): List; + push(...values: Array): List; + pop(): List; + unshift(...values: Array): List; + shift(): List; + update(index: number, notSetValue: T, updater: (value: T) => T): this; + update(index: number, updater: (value: T) => T): this; + update(updater: (value: this) => R): R; + merge(...collections: Array | Array>): this; + mergeWith(merger: (oldVal: T, newVal: T, key: number) => T, ...collections: Array | Array>): this; + mergeDeep(...collections: Array | Array>): this; + mergeDeepWith(merger: (oldVal: T, newVal: T, key: number) => T, ...collections: Array | Array>): this; + setSize(size: number): List; + // Deep persistent changes + setIn(keyPath: Iterable, value: any): this; + deleteIn(keyPath: Iterable): this; + removeIn(keyPath: Iterable): this; + updateIn(keyPath: Iterable, notSetValue: any, updater: (value: any) => any): this; + updateIn(keyPath: Iterable, updater: (value: any) => any): this; + mergeIn(keyPath: Iterable, ...collections: Array): this; + mergeDeepIn(keyPath: Iterable, ...collections: Array): this; + // Transient changes + withMutations(mutator: (mutable: this) => any): this; + asMutable(): this; + asImmutable(): this; + // Sequence algorithms + concat(...valuesOrCollections: Array | C>): List; + map(mapper: (value: T, key: number, iter: this) => M, context?: any): List; + flatMap(mapper: (value: T, key: number, iter: this) => Iterable, context?: any): List; + filter(predicate: (value: T, index: number, iter: this) => value is F, context?: any): List; + filter(predicate: (value: T, index: number, iter: this) => any, context?: any): this; + } + export module Map { + function isMap(maybeMap: any): maybeMap is Map; + function of(...keyValues: Array): Map; + } + export function Map(collection: Iterable<[K, V]>): Map; + export function Map(collection: Iterable>): Map; + export function Map(obj: {[key: string]: V}): Map; + export function Map(): Map; + export function Map(): Map; + export interface Map extends Collection.Keyed { + // Persistent changes + set(key: K, value: V): this; + delete(key: K): this; + remove(key: K): this; + deleteAll(keys: Iterable): this; + removeAll(keys: Iterable): this; + clear(): this; + update(key: K, notSetValue: V, updater: (value: V) => V): this; + update(key: K, updater: (value: V) => V): this; + update(updater: (value: this) => R): R; + merge(...collections: Array | {[key: string]: V}>): this; + mergeWith(merger: (oldVal: V, newVal: V, key: K) => V, ...collections: Array | {[key: string]: V}>): this; + mergeDeep(...collections: Array | {[key: string]: V}>): this; + mergeDeepWith(merger: (oldVal: V, newVal: V, key: K) => V, ...collections: Array | {[key: string]: V}>): this; + // Deep persistent changes + setIn(keyPath: Iterable, value: any): this; + deleteIn(keyPath: Iterable): this; + removeIn(keyPath: Iterable): this; + updateIn(keyPath: Iterable, notSetValue: any, updater: (value: any) => any): this; + updateIn(keyPath: Iterable, updater: (value: any) => any): this; + mergeIn(keyPath: Iterable, ...collections: Array): this; + mergeDeepIn(keyPath: Iterable, ...collections: Array): this; + // Transient changes + withMutations(mutator: (mutable: this) => any): this; + asMutable(): this; + asImmutable(): this; + // Sequence algorithms + concat(...collections: Array>): Map; + concat(...collections: Array<{[key: string]: C}>): Map; + map(mapper: (value: V, key: K, iter: this) => M, context?: any): Map; + mapKeys(mapper: (key: K, value: V, iter: this) => M, context?: any): Map; + mapEntries(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], context?: any): Map; + flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Map; + filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Map; + filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; + } + export module OrderedMap { + function isOrderedMap(maybeOrderedMap: any): maybeOrderedMap is OrderedMap; + } + export function OrderedMap(collection: Iterable<[K, V]>): OrderedMap; + export function OrderedMap(collection: Iterable>): OrderedMap; + export function OrderedMap(obj: {[key: string]: V}): OrderedMap; + export function OrderedMap(): OrderedMap; + export function OrderedMap(): OrderedMap; + export interface OrderedMap extends Map { + // Sequence algorithms + concat(...collections: Array>): OrderedMap; + concat(...collections: Array<{[key: string]: C}>): OrderedMap; + map(mapper: (value: V, key: K, iter: this) => M, context?: any): OrderedMap; + mapKeys(mapper: (key: K, value: V, iter: this) => M, context?: any): OrderedMap; + mapEntries(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], context?: any): OrderedMap; + flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): OrderedMap; + filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): OrderedMap; + filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; + } + export module Set { + function isSet(maybeSet: any): maybeSet is Set; + function of(...values: Array): Set; + function fromKeys(iter: Collection): Set; + function fromKeys(obj: {[key: string]: any}): Set; + function intersect(sets: Iterable>): Set; + function union(sets: Iterable>): Set; + } + export function Set(): Set; + export function Set(): Set; + export function Set(collection: Iterable): Set; + export interface Set extends Collection.Set { + // Persistent changes + add(value: T): this; + delete(value: T): this; + remove(value: T): this; + clear(): this; + union(...collections: Array | Array>): this; + merge(...collections: Array | Array>): this; + intersect(...collections: Array | Array>): this; + subtract(...collections: Array | Array>): this; + // Transient changes + withMutations(mutator: (mutable: this) => any): this; + asMutable(): this; + asImmutable(): this; + // Sequence algorithms + concat(...valuesOrCollections: Array | C>): Set; + map(mapper: (value: T, key: never, iter: this) => M, context?: any): Set; + flatMap(mapper: (value: T, key: never, iter: this) => Iterable, context?: any): Set; + filter(predicate: (value: T, key: never, iter: this) => value is F, context?: any): Set; + filter(predicate: (value: T, key: never, iter: this) => any, context?: any): this; + } + export module OrderedSet { + function isOrderedSet(maybeOrderedSet: any): boolean; + function of(...values: Array): OrderedSet; + function fromKeys(iter: Collection): OrderedSet; + function fromKeys(obj: {[key: string]: any}): OrderedSet; + } + export function OrderedSet(): OrderedSet; + export function OrderedSet(): OrderedSet; + export function OrderedSet(collection: Iterable): OrderedSet; + export interface OrderedSet extends Set { + // Sequence algorithms + concat(...valuesOrCollections: Array | C>): OrderedSet; + map(mapper: (value: T, key: never, iter: this) => M, context?: any): OrderedSet; + flatMap(mapper: (value: T, key: never, iter: this) => Iterable, context?: any): OrderedSet; + filter(predicate: (value: T, key: never, iter: this) => value is F, context?: any): OrderedSet; + filter(predicate: (value: T, key: never, iter: this) => any, context?: any): this; + zip(...collections: Array>): OrderedSet; + zipWith(zipper: (value: T, otherValue: U) => Z, otherCollection: Collection): OrderedSet; + zipWith(zipper: (value: T, otherValue: U, thirdValue: V) => Z, otherCollection: Collection, thirdCollection: Collection): OrderedSet; + zipWith(zipper: (...any: Array) => Z, ...collections: Array>): OrderedSet; + } + export module Stack { + function isStack(maybeStack: any): maybeStack is Stack; + function of(...values: Array): Stack; + } + export function Stack(): Stack; + export function Stack(): Stack; + export function Stack(collection: Iterable): Stack; + export interface Stack extends Collection.Indexed { + // Reading values + peek(): T | undefined; + // Persistent changes + clear(): Stack; + unshift(...values: Array): Stack; + unshiftAll(iter: Iterable): Stack; + shift(): Stack; + push(...values: Array): Stack; + pushAll(iter: Iterable): Stack; + pop(): Stack; + // Transient changes + withMutations(mutator: (mutable: this) => any): this; + asMutable(): this; + asImmutable(): this; + // Sequence algorithms + concat(...valuesOrCollections: Array | C>): Stack; + map(mapper: (value: T, key: number, iter: this) => M, context?: any): Stack; + flatMap(mapper: (value: T, key: number, iter: this) => Iterable, context?: any): Stack; + filter(predicate: (value: T, index: number, iter: this) => value is F, context?: any): Set; + filter(predicate: (value: T, index: number, iter: this) => any, context?: any): this; + } + export function Range(start?: number, end?: number, step?: number): Seq.Indexed; + export function Repeat(value: T, times?: number): Seq.Indexed; + export module Record { + export function isRecord(maybeRecord: any): maybeRecord is Record.Instance; + export function getDescriptiveName(record: Instance): string; + export interface Class { + (values?: Partial | Iterable<[string, any]>): Instance & Readonly; + new (values?: Partial | Iterable<[string, any]>): Instance & Readonly; + } + export interface Instance { + readonly size: number; + // Reading values + has(key: string): boolean; + get(key: K): T[K]; + // Reading deep values + hasIn(keyPath: Iterable): boolean; + getIn(keyPath: Iterable): any; + // Value equality + equals(other: any): boolean; + hashCode(): number; + // Persistent changes + set(key: K, value: T[K]): this; + update(key: K, updater: (value: T[K]) => T[K]): this; + merge(...collections: Array | Iterable<[string, any]>>): this; + mergeDeep(...collections: Array | Iterable<[string, any]>>): this; + mergeWith(merger: (oldVal: any, newVal: any, key: keyof T) => any, ...collections: Array | Iterable<[string, any]>>): this; + mergeDeepWith(merger: (oldVal: any, newVal: any, key: any) => any, ...collections: Array | Iterable<[string, any]>>): this; + delete(key: K): this; + remove(key: K): this; + clear(): this; + // Deep persistent changes + setIn(keyPath: Iterable, value: any): this; + updateIn(keyPath: Iterable, updater: (value: any) => any): this; + mergeIn(keyPath: Iterable, ...collections: Array): this; + mergeDeepIn(keyPath: Iterable, ...collections: Array): this; + deleteIn(keyPath: Iterable): this; + removeIn(keyPath: Iterable): this; + // Conversion to JavaScript types + toJS(): { [K in keyof T]: any }; + toJSON(): T; + toObject(): T; + // Transient changes + withMutations(mutator: (mutable: this) => any): this; + asMutable(): this; + asImmutable(): this; + // Sequence algorithms + toSeq(): Seq.Keyed; + [Symbol.iterator](): IterableIterator<[keyof T, T[keyof T]]>; + } + } + export function Record(defaultValues: T, name?: string): Record.Class; + export module Seq { + function isSeq(maybeSeq: any): maybeSeq is Seq.Indexed | Seq.Keyed; + function of(...values: Array): Seq.Indexed; + export module Keyed {} + export function Keyed(collection: Iterable<[K, V]>): Seq.Keyed; + export function Keyed(obj: {[key: string]: V}): Seq.Keyed; + export function Keyed(): Seq.Keyed; + export function Keyed(): Seq.Keyed; + export interface Keyed extends Seq, Collection.Keyed { + toJS(): Object; + toJSON(): { [key: string]: V }; + toSeq(): this; + concat(...collections: Array>): Seq.Keyed; + concat(...collections: Array<{[key: string]: C}>): Seq.Keyed; + map(mapper: (value: V, key: K, iter: this) => M, context?: any): Seq.Keyed; + mapKeys(mapper: (key: K, value: V, iter: this) => M, context?: any): Seq.Keyed; + mapEntries(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], context?: any): Seq.Keyed; + flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Seq.Keyed; + filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Seq.Keyed; + filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; + } + module Indexed { + function of(...values: Array): Seq.Indexed; + } + export function Indexed(): Seq.Indexed; + export function Indexed(): Seq.Indexed; + export function Indexed(collection: Iterable): Seq.Indexed; + export interface Indexed extends Seq, Collection.Indexed { + toJS(): Array; + toJSON(): Array; + toSeq(): this; + concat(...valuesOrCollections: Array | C>): Seq.Indexed; + map(mapper: (value: T, key: number, iter: this) => M, context?: any): Seq.Indexed; + flatMap(mapper: (value: T, key: number, iter: this) => Iterable, context?: any): Seq.Indexed; + filter(predicate: (value: T, index: number, iter: this) => value is F, context?: any): Seq.Indexed; + filter(predicate: (value: T, index: number, iter: this) => any, context?: any): this; + } + export module Set { + function of(...values: Array): Seq.Set; + } + export function Set(): Seq.Set; + export function Set(): Seq.Set; + export function Set(collection: Iterable): Seq.Set; + export interface Set extends Seq, Collection.Set { + toJS(): Array; + toJSON(): Array; + toSeq(): this; + concat(...valuesOrCollections: Array | C>): Seq.Set; + map(mapper: (value: T, key: never, iter: this) => M, context?: any): Seq.Set; + flatMap(mapper: (value: T, key: never, iter: this) => Iterable, context?: any): Seq.Set; + filter(predicate: (value: T, key: never, iter: this) => value is F, context?: any): Seq.Set; + filter(predicate: (value: T, key: never, iter: this) => any, context?: any): this; + } + } + export function Seq>(seq: S): S; + export function Seq(collection: Collection.Keyed): Seq.Keyed; + export function Seq(collection: Collection.Indexed): Seq.Indexed; + export function Seq(collection: Collection.Set): Seq.Set; + export function Seq(collection: Iterable): Seq.Indexed; + export function Seq(obj: {[key: string]: V}): Seq.Keyed; + export function Seq(): Seq; + export interface Seq extends Collection { + readonly size: number | undefined; + // Force evaluation + cacheResult(): this; + // Sequence algorithms + map(mapper: (value: V, key: K, iter: this) => M, context?: any): Seq; + flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Seq; + filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Seq; + filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; + } + export module Collection { + function isKeyed(maybeKeyed: any): maybeKeyed is Collection.Keyed; + function isIndexed(maybeIndexed: any): maybeIndexed is Collection.Indexed; + function isAssociative(maybeAssociative: any): maybeAssociative is Collection.Keyed | Collection.Indexed; + function isOrdered(maybeOrdered: any): boolean; + export module Keyed {} + export function Keyed(collection: Iterable<[K, V]>): Collection.Keyed; + export function Keyed(obj: {[key: string]: V}): Collection.Keyed; + export interface Keyed extends Collection { + toJS(): Object; + toJSON(): { [key: string]: V }; + toSeq(): Seq.Keyed; + // Sequence functions + flip(): this; + concat(...collections: Array>): Collection.Keyed; + concat(...collections: Array<{[key: string]: C}>): Collection.Keyed; + map(mapper: (value: V, key: K, iter: this) => M, context?: any): Collection.Keyed; + mapKeys(mapper: (key: K, value: V, iter: this) => M, context?: any): Collection.Keyed; + mapEntries(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], context?: any): Collection.Keyed; + flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Collection.Keyed; + filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Collection.Keyed; + filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; + [Symbol.iterator](): IterableIterator<[K, V]>; + } + export module Indexed {} + export function Indexed(collection: Iterable): Collection.Indexed; + export interface Indexed extends Collection { + toJS(): Array; + toJSON(): Array; + // Reading values + get(index: number, notSetValue: NSV): T | NSV; + get(index: number): T | undefined; + // Conversion to Seq + toSeq(): Seq.Indexed; + fromEntrySeq(): Seq.Keyed; + // Combination + interpose(separator: T): this; + interleave(...collections: Array>): this; + splice(index: number, removeNum: number, ...values: Array): this; + zip(...collections: Array>): Collection.Indexed; + zipWith(zipper: (value: T, otherValue: U) => Z, otherCollection: Collection): Collection.Indexed; + zipWith(zipper: (value: T, otherValue: U, thirdValue: V) => Z, otherCollection: Collection, thirdCollection: Collection): Collection.Indexed; + zipWith(zipper: (...any: Array) => Z, ...collections: Array>): Collection.Indexed; + // Search for value + indexOf(searchValue: T): number; + lastIndexOf(searchValue: T): number; + findIndex(predicate: (value: T, index: number, iter: this) => boolean, context?: any): number; + findLastIndex(predicate: (value: T, index: number, iter: this) => boolean, context?: any): number; + // Sequence algorithms + concat(...valuesOrCollections: Array | C>): Collection.Indexed; + map(mapper: (value: T, key: number, iter: this) => M, context?: any): Collection.Indexed; + flatMap(mapper: (value: T, key: number, iter: this) => Iterable, context?: any): Collection.Indexed; + filter(predicate: (value: T, index: number, iter: this) => value is F, context?: any): Collection.Indexed; + filter(predicate: (value: T, index: number, iter: this) => any, context?: any): this; + [Symbol.iterator](): IterableIterator; + } + export module Set {} + export function Set(collection: Iterable): Collection.Set; + export interface Set extends Collection { + toJS(): Array; + toJSON(): Array; + toSeq(): Seq.Set; + // Sequence algorithms + concat(...valuesOrCollections: Array | C>): Collection.Set; + map(mapper: (value: T, key: never, iter: this) => M, context?: any): Collection.Set; + flatMap(mapper: (value: T, key: never, iter: this) => Iterable, context?: any): Collection.Set; + filter(predicate: (value: T, key: never, iter: this) => value is F, context?: any): Collection.Set; + filter(predicate: (value: T, key: never, iter: this) => any, context?: any): this; + [Symbol.iterator](): IterableIterator; + } + } + export function Collection>(collection: I): I; + export function Collection(collection: Iterable): Collection.Indexed; + export function Collection(obj: {[key: string]: V}): Collection.Keyed; + export interface Collection extends ValueObject { + // Value equality + equals(other: any): boolean; + hashCode(): number; + // Reading values + get(key: K, notSetValue: NSV): V | NSV; + get(key: K): V | undefined; + has(key: K): boolean; + includes(value: V): boolean; + contains(value: V): boolean; + first(): V | undefined; + last(): V | undefined; + // Reading deep values + getIn(searchKeyPath: Iterable, notSetValue?: any): any; + hasIn(searchKeyPath: Iterable): boolean; + // Persistent changes + update(updater: (value: this) => R): R; + // Conversion to JavaScript types + toJS(): Array | { [key: string]: any }; + toJSON(): Array | { [key: string]: V }; + toArray(): Array; + toObject(): { [key: string]: V }; + // Conversion to Collections + toMap(): Map; + toOrderedMap(): OrderedMap; + toSet(): Set; + toOrderedSet(): OrderedSet; + toList(): List; + toStack(): Stack; + // Conversion to Seq + toSeq(): this; + toKeyedSeq(): Seq.Keyed; + toIndexedSeq(): Seq.Indexed; + toSetSeq(): Seq.Set; + // Iterators + keys(): IterableIterator; + values(): IterableIterator; + entries(): IterableIterator<[K, V]>; + // Collections (Seq) + keySeq(): Seq.Indexed; + valueSeq(): Seq.Indexed; + entrySeq(): Seq.Indexed<[K, V]>; + // Sequence algorithms + map(mapper: (value: V, key: K, iter: this) => M, context?: any): Collection; + filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Collection; + filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; + filterNot(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; + reverse(): this; + sort(comparator?: (valueA: V, valueB: V) => number): this; + sortBy(comparatorValueMapper: (value: V, key: K, iter: this) => C, comparator?: (valueA: C, valueB: C) => number): this; + groupBy(grouper: (value: V, key: K, iter: this) => G, context?: any): /*Map*/Seq.Keyed>; + // Side effects + forEach(sideEffect: (value: V, key: K, iter: this) => any, context?: any): number; + // Creating subsets + slice(begin?: number, end?: number): this; + rest(): this; + butLast(): this; + skip(amount: number): this; + skipLast(amount: number): this; + skipWhile(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; + skipUntil(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; + take(amount: number): this; + takeLast(amount: number): this; + takeWhile(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; + takeUntil(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; + // Combination + concat(...valuesOrCollections: Array): Collection; + flatten(depth?: number): Collection; + flatten(shallow?: boolean): Collection; + flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Collection; + // Reducing a value + reduce(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R; + reduce(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; + reduceRight(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R; + reduceRight(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; + every(predicate: (value: V, key: K, iter: this) => boolean, context?: any): boolean; + some(predicate: (value: V, key: K, iter: this) => boolean, context?: any): boolean; + join(separator?: string): string; + isEmpty(): boolean; + count(): number; + count(predicate: (value: V, key: K, iter: this) => boolean, context?: any): number; + countBy(grouper: (value: V, key: K, iter: this) => G, context?: any): Map; + // Search for value + find(predicate: (value: V, key: K, iter: this) => boolean, context?: any, notSetValue?: V): V | undefined; + findLast(predicate: (value: V, key: K, iter: this) => boolean, context?: any, notSetValue?: V): V | undefined; + findEntry(predicate: (value: V, key: K, iter: this) => boolean, context?: any, notSetValue?: V): [K, V] | undefined; + findLastEntry(predicate: (value: V, key: K, iter: this) => boolean, context?: any, notSetValue?: V): [K, V] | undefined; + findKey(predicate: (value: V, key: K, iter: this) => boolean, context?: any): K | undefined; + findLastKey(predicate: (value: V, key: K, iter: this) => boolean, context?: any): K | undefined; + keyOf(searchValue: V): K | undefined; + lastKeyOf(searchValue: V): K | undefined; + max(comparator?: (valueA: V, valueB: V) => number): V | undefined; + maxBy(comparatorValueMapper: (value: V, key: K, iter: this) => C, comparator?: (valueA: C, valueB: C) => number): V | undefined; + min(comparator?: (valueA: V, valueB: V) => number): V | undefined; + minBy(comparatorValueMapper: (value: V, key: K, iter: this) => C, comparator?: (valueA: C, valueB: C) => number): V | undefined; + // Comparison + isSubset(iter: Iterable): boolean; + isSuperset(iter: Iterable): boolean; + readonly size: number; + } +} +declare module "immutable" { + export = Immutable +} + + +//// [complex.js] +//// [immutable.js] diff --git a/tests/baselines/reference/complexRecursiveCollections.symbols b/tests/baselines/reference/complexRecursiveCollections.symbols index d5eee915d57..8533f5220a2 100644 --- a/tests/baselines/reference/complexRecursiveCollections.symbols +++ b/tests/baselines/reference/complexRecursiveCollections.symbols @@ -1,3806 +1,3806 @@ -=== tests/cases/compiler/complex.d.ts === +=== tests/cases/compiler/complex.ts === interface Ara { t: T } ->Ara : Symbol(Ara, Decl(complex.d.ts, 0, 0)) ->T : Symbol(T, Decl(complex.d.ts, 0, 14)) ->t : Symbol(Ara.t, Decl(complex.d.ts, 0, 18)) ->T : Symbol(T, Decl(complex.d.ts, 0, 14)) +>Ara : Symbol(Ara, Decl(complex.ts, 0, 0)) +>T : Symbol(T, Decl(complex.ts, 0, 14)) +>t : Symbol(Ara.t, Decl(complex.ts, 0, 18)) +>T : Symbol(T, Decl(complex.ts, 0, 14)) interface Collection { ->Collection : Symbol(Collection, Decl(complex.d.ts, 0, 25)) ->K : Symbol(K, Decl(complex.d.ts, 1, 21)) ->V : Symbol(V, Decl(complex.d.ts, 1, 23)) +>Collection : Symbol(Collection, Decl(complex.ts, 0, 25)) +>K : Symbol(K, Decl(complex.ts, 1, 21)) +>V : Symbol(V, Decl(complex.ts, 1, 23)) map(mapper: (value: V, key: K, iter: this) => M): Collection; ->map : Symbol(Collection.map, Decl(complex.d.ts, 1, 28)) ->M : Symbol(M, Decl(complex.d.ts, 2, 8)) ->mapper : Symbol(mapper, Decl(complex.d.ts, 2, 11)) ->value : Symbol(value, Decl(complex.d.ts, 2, 20)) ->V : Symbol(V, Decl(complex.d.ts, 1, 23)) ->key : Symbol(key, Decl(complex.d.ts, 2, 29)) ->K : Symbol(K, Decl(complex.d.ts, 1, 21)) ->iter : Symbol(iter, Decl(complex.d.ts, 2, 37)) ->M : Symbol(M, Decl(complex.d.ts, 2, 8)) ->Collection : Symbol(Collection, Decl(complex.d.ts, 0, 25)) ->K : Symbol(K, Decl(complex.d.ts, 1, 21)) ->M : Symbol(M, Decl(complex.d.ts, 2, 8)) +>map : Symbol(Collection.map, Decl(complex.ts, 1, 28)) +>M : Symbol(M, Decl(complex.ts, 2, 8)) +>mapper : Symbol(mapper, Decl(complex.ts, 2, 11)) +>value : Symbol(value, Decl(complex.ts, 2, 20)) +>V : Symbol(V, Decl(complex.ts, 1, 23)) +>key : Symbol(key, Decl(complex.ts, 2, 29)) +>K : Symbol(K, Decl(complex.ts, 1, 21)) +>iter : Symbol(iter, Decl(complex.ts, 2, 37)) +>M : Symbol(M, Decl(complex.ts, 2, 8)) +>Collection : Symbol(Collection, Decl(complex.ts, 0, 25)) +>K : Symbol(K, Decl(complex.ts, 1, 21)) +>M : Symbol(M, Decl(complex.ts, 2, 8)) flatMap(mapper: (value: V, key: K, iter: this) => Ara, context?: any): Collection; ->flatMap : Symbol(Collection.flatMap, Decl(complex.d.ts, 2, 74)) ->M : Symbol(M, Decl(complex.d.ts, 3, 12)) ->mapper : Symbol(mapper, Decl(complex.d.ts, 3, 15)) ->value : Symbol(value, Decl(complex.d.ts, 3, 24)) ->V : Symbol(V, Decl(complex.d.ts, 1, 23)) ->key : Symbol(key, Decl(complex.d.ts, 3, 33)) ->K : Symbol(K, Decl(complex.d.ts, 1, 21)) ->iter : Symbol(iter, Decl(complex.d.ts, 3, 41)) ->Ara : Symbol(Ara, Decl(complex.d.ts, 0, 0)) ->M : Symbol(M, Decl(complex.d.ts, 3, 12)) ->context : Symbol(context, Decl(complex.d.ts, 3, 64)) ->Collection : Symbol(Collection, Decl(complex.d.ts, 0, 25)) ->K : Symbol(K, Decl(complex.d.ts, 1, 21)) ->M : Symbol(M, Decl(complex.d.ts, 3, 12)) +>flatMap : Symbol(Collection.flatMap, Decl(complex.ts, 2, 74)) +>M : Symbol(M, Decl(complex.ts, 3, 12)) +>mapper : Symbol(mapper, Decl(complex.ts, 3, 15)) +>value : Symbol(value, Decl(complex.ts, 3, 24)) +>V : Symbol(V, Decl(complex.ts, 1, 23)) +>key : Symbol(key, Decl(complex.ts, 3, 33)) +>K : Symbol(K, Decl(complex.ts, 1, 21)) +>iter : Symbol(iter, Decl(complex.ts, 3, 41)) +>Ara : Symbol(Ara, Decl(complex.ts, 0, 0)) +>M : Symbol(M, Decl(complex.ts, 3, 12)) +>context : Symbol(context, Decl(complex.ts, 3, 64)) +>Collection : Symbol(Collection, Decl(complex.ts, 0, 25)) +>K : Symbol(K, Decl(complex.ts, 1, 21)) +>M : Symbol(M, Decl(complex.ts, 3, 12)) // these seem necessary to push it over the top for memory usage reduce(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R; ->reduce : Symbol(Collection.reduce, Decl(complex.d.ts, 3, 98), Decl(complex.d.ts, 5, 113)) ->R : Symbol(R, Decl(complex.d.ts, 5, 11)) ->reducer : Symbol(reducer, Decl(complex.d.ts, 5, 14)) ->reduction : Symbol(reduction, Decl(complex.d.ts, 5, 24)) ->R : Symbol(R, Decl(complex.d.ts, 5, 11)) ->value : Symbol(value, Decl(complex.d.ts, 5, 37)) ->V : Symbol(V, Decl(complex.d.ts, 1, 23)) ->key : Symbol(key, Decl(complex.d.ts, 5, 47)) ->K : Symbol(K, Decl(complex.d.ts, 1, 21)) ->iter : Symbol(iter, Decl(complex.d.ts, 5, 55)) ->R : Symbol(R, Decl(complex.d.ts, 5, 11)) ->initialReduction : Symbol(initialReduction, Decl(complex.d.ts, 5, 73)) ->R : Symbol(R, Decl(complex.d.ts, 5, 11)) ->context : Symbol(context, Decl(complex.d.ts, 5, 94)) ->R : Symbol(R, Decl(complex.d.ts, 5, 11)) +>reduce : Symbol(Collection.reduce, Decl(complex.ts, 3, 98), Decl(complex.ts, 5, 113)) +>R : Symbol(R, Decl(complex.ts, 5, 11)) +>reducer : Symbol(reducer, Decl(complex.ts, 5, 14)) +>reduction : Symbol(reduction, Decl(complex.ts, 5, 24)) +>R : Symbol(R, Decl(complex.ts, 5, 11)) +>value : Symbol(value, Decl(complex.ts, 5, 37)) +>V : Symbol(V, Decl(complex.ts, 1, 23)) +>key : Symbol(key, Decl(complex.ts, 5, 47)) +>K : Symbol(K, Decl(complex.ts, 1, 21)) +>iter : Symbol(iter, Decl(complex.ts, 5, 55)) +>R : Symbol(R, Decl(complex.ts, 5, 11)) +>initialReduction : Symbol(initialReduction, Decl(complex.ts, 5, 73)) +>R : Symbol(R, Decl(complex.ts, 5, 11)) +>context : Symbol(context, Decl(complex.ts, 5, 94)) +>R : Symbol(R, Decl(complex.ts, 5, 11)) reduce(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; ->reduce : Symbol(Collection.reduce, Decl(complex.d.ts, 3, 98), Decl(complex.d.ts, 5, 113)) ->R : Symbol(R, Decl(complex.d.ts, 6, 11)) ->reducer : Symbol(reducer, Decl(complex.d.ts, 6, 14)) ->reduction : Symbol(reduction, Decl(complex.d.ts, 6, 24)) ->V : Symbol(V, Decl(complex.d.ts, 1, 23)) ->R : Symbol(R, Decl(complex.d.ts, 6, 11)) ->value : Symbol(value, Decl(complex.d.ts, 6, 41)) ->V : Symbol(V, Decl(complex.d.ts, 1, 23)) ->key : Symbol(key, Decl(complex.d.ts, 6, 51)) ->K : Symbol(K, Decl(complex.d.ts, 1, 21)) ->iter : Symbol(iter, Decl(complex.d.ts, 6, 59)) ->R : Symbol(R, Decl(complex.d.ts, 6, 11)) ->R : Symbol(R, Decl(complex.d.ts, 6, 11)) +>reduce : Symbol(Collection.reduce, Decl(complex.ts, 3, 98), Decl(complex.ts, 5, 113)) +>R : Symbol(R, Decl(complex.ts, 6, 11)) +>reducer : Symbol(reducer, Decl(complex.ts, 6, 14)) +>reduction : Symbol(reduction, Decl(complex.ts, 6, 24)) +>V : Symbol(V, Decl(complex.ts, 1, 23)) +>R : Symbol(R, Decl(complex.ts, 6, 11)) +>value : Symbol(value, Decl(complex.ts, 6, 41)) +>V : Symbol(V, Decl(complex.ts, 1, 23)) +>key : Symbol(key, Decl(complex.ts, 6, 51)) +>K : Symbol(K, Decl(complex.ts, 1, 21)) +>iter : Symbol(iter, Decl(complex.ts, 6, 59)) +>R : Symbol(R, Decl(complex.ts, 6, 11)) +>R : Symbol(R, Decl(complex.ts, 6, 11)) toSeq(): Seq; ->toSeq : Symbol(Collection.toSeq, Decl(complex.d.ts, 6, 81)) ->Seq : Symbol(Seq, Decl(complex.d.ts, 8, 1)) ->K : Symbol(K, Decl(complex.d.ts, 1, 21)) ->V : Symbol(V, Decl(complex.d.ts, 1, 23)) +>toSeq : Symbol(Collection.toSeq, Decl(complex.ts, 6, 81)) +>Seq : Symbol(Seq, Decl(complex.ts, 8, 1)) +>K : Symbol(K, Decl(complex.ts, 1, 21)) +>V : Symbol(V, Decl(complex.ts, 1, 23)) } interface Seq extends Collection { ->Seq : Symbol(Seq, Decl(complex.d.ts, 8, 1)) ->K : Symbol(K, Decl(complex.d.ts, 9, 14)) ->V : Symbol(V, Decl(complex.d.ts, 9, 16)) ->Collection : Symbol(Collection, Decl(complex.d.ts, 0, 25)) ->K : Symbol(K, Decl(complex.d.ts, 9, 14)) ->V : Symbol(V, Decl(complex.d.ts, 9, 16)) +>Seq : Symbol(Seq, Decl(complex.ts, 8, 1)) +>K : Symbol(K, Decl(complex.ts, 9, 14)) +>V : Symbol(V, Decl(complex.ts, 9, 16)) +>Collection : Symbol(Collection, Decl(complex.ts, 0, 25)) +>K : Symbol(K, Decl(complex.ts, 9, 14)) +>V : Symbol(V, Decl(complex.ts, 9, 16)) } interface N1 extends Collection { ->N1 : Symbol(N1, Decl(complex.d.ts, 10, 1)) ->T : Symbol(T, Decl(complex.d.ts, 11, 13)) ->Collection : Symbol(Collection, Decl(complex.d.ts, 0, 25)) ->T : Symbol(T, Decl(complex.d.ts, 11, 13)) +>N1 : Symbol(N1, Decl(complex.ts, 10, 1)) +>T : Symbol(T, Decl(complex.ts, 11, 13)) +>Collection : Symbol(Collection, Decl(complex.ts, 0, 25)) +>T : Symbol(T, Decl(complex.ts, 11, 13)) map(mapper: (value: T, key: void, iter: this) => M): N1; ->map : Symbol(N1.map, Decl(complex.d.ts, 11, 45)) ->M : Symbol(M, Decl(complex.d.ts, 12, 8)) ->mapper : Symbol(mapper, Decl(complex.d.ts, 12, 11)) ->value : Symbol(value, Decl(complex.d.ts, 12, 20)) ->T : Symbol(T, Decl(complex.d.ts, 11, 13)) ->key : Symbol(key, Decl(complex.d.ts, 12, 29)) ->iter : Symbol(iter, Decl(complex.d.ts, 12, 40)) ->M : Symbol(M, Decl(complex.d.ts, 12, 8)) ->N1 : Symbol(N1, Decl(complex.d.ts, 10, 1)) ->M : Symbol(M, Decl(complex.d.ts, 12, 8)) +>map : Symbol(N1.map, Decl(complex.ts, 11, 45)) +>M : Symbol(M, Decl(complex.ts, 12, 8)) +>mapper : Symbol(mapper, Decl(complex.ts, 12, 11)) +>value : Symbol(value, Decl(complex.ts, 12, 20)) +>T : Symbol(T, Decl(complex.ts, 11, 13)) +>key : Symbol(key, Decl(complex.ts, 12, 29)) +>iter : Symbol(iter, Decl(complex.ts, 12, 40)) +>M : Symbol(M, Decl(complex.ts, 12, 8)) +>N1 : Symbol(N1, Decl(complex.ts, 10, 1)) +>M : Symbol(M, Decl(complex.ts, 12, 8)) flatMap(mapper: (value: T, key: void, iter: this) => Ara, context?: any): N1; ->flatMap : Symbol(N1.flatMap, Decl(complex.d.ts, 12, 66)) ->M : Symbol(M, Decl(complex.d.ts, 13, 12)) ->mapper : Symbol(mapper, Decl(complex.d.ts, 13, 15)) ->value : Symbol(value, Decl(complex.d.ts, 13, 24)) ->T : Symbol(T, Decl(complex.d.ts, 11, 13)) ->key : Symbol(key, Decl(complex.d.ts, 13, 33)) ->iter : Symbol(iter, Decl(complex.d.ts, 13, 44)) ->Ara : Symbol(Ara, Decl(complex.d.ts, 0, 0)) ->M : Symbol(M, Decl(complex.d.ts, 13, 12)) ->context : Symbol(context, Decl(complex.d.ts, 13, 67)) ->N1 : Symbol(N1, Decl(complex.d.ts, 10, 1)) ->M : Symbol(M, Decl(complex.d.ts, 13, 12)) +>flatMap : Symbol(N1.flatMap, Decl(complex.ts, 12, 66)) +>M : Symbol(M, Decl(complex.ts, 13, 12)) +>mapper : Symbol(mapper, Decl(complex.ts, 13, 15)) +>value : Symbol(value, Decl(complex.ts, 13, 24)) +>T : Symbol(T, Decl(complex.ts, 11, 13)) +>key : Symbol(key, Decl(complex.ts, 13, 33)) +>iter : Symbol(iter, Decl(complex.ts, 13, 44)) +>Ara : Symbol(Ara, Decl(complex.ts, 0, 0)) +>M : Symbol(M, Decl(complex.ts, 13, 12)) +>context : Symbol(context, Decl(complex.ts, 13, 67)) +>N1 : Symbol(N1, Decl(complex.ts, 10, 1)) +>M : Symbol(M, Decl(complex.ts, 13, 12)) } interface N2 extends N1 { ->N2 : Symbol(N2, Decl(complex.d.ts, 14, 1)) ->T : Symbol(T, Decl(complex.d.ts, 15, 13)) ->N1 : Symbol(N1, Decl(complex.d.ts, 10, 1)) ->T : Symbol(T, Decl(complex.d.ts, 15, 13)) +>N2 : Symbol(N2, Decl(complex.ts, 14, 1)) +>T : Symbol(T, Decl(complex.ts, 15, 13)) +>N1 : Symbol(N1, Decl(complex.ts, 10, 1)) +>T : Symbol(T, Decl(complex.ts, 15, 13)) map(mapper: (value: T, key: void, iter: this) => M): N2; ->map : Symbol(N2.map, Decl(complex.d.ts, 15, 31)) ->M : Symbol(M, Decl(complex.d.ts, 16, 8)) ->mapper : Symbol(mapper, Decl(complex.d.ts, 16, 11)) ->value : Symbol(value, Decl(complex.d.ts, 16, 20)) ->T : Symbol(T, Decl(complex.d.ts, 15, 13)) ->key : Symbol(key, Decl(complex.d.ts, 16, 29)) ->iter : Symbol(iter, Decl(complex.d.ts, 16, 40)) ->M : Symbol(M, Decl(complex.d.ts, 16, 8)) ->N2 : Symbol(N2, Decl(complex.d.ts, 14, 1)) ->M : Symbol(M, Decl(complex.d.ts, 16, 8)) +>map : Symbol(N2.map, Decl(complex.ts, 15, 31)) +>M : Symbol(M, Decl(complex.ts, 16, 8)) +>mapper : Symbol(mapper, Decl(complex.ts, 16, 11)) +>value : Symbol(value, Decl(complex.ts, 16, 20)) +>T : Symbol(T, Decl(complex.ts, 15, 13)) +>key : Symbol(key, Decl(complex.ts, 16, 29)) +>iter : Symbol(iter, Decl(complex.ts, 16, 40)) +>M : Symbol(M, Decl(complex.ts, 16, 8)) +>N2 : Symbol(N2, Decl(complex.ts, 14, 1)) +>M : Symbol(M, Decl(complex.ts, 16, 8)) flatMap(mapper: (value: T, key: void, iter: this) => Ara, context?: any): N2; ->flatMap : Symbol(N2.flatMap, Decl(complex.d.ts, 16, 66)) ->M : Symbol(M, Decl(complex.d.ts, 17, 12)) ->mapper : Symbol(mapper, Decl(complex.d.ts, 17, 15)) ->value : Symbol(value, Decl(complex.d.ts, 17, 24)) ->T : Symbol(T, Decl(complex.d.ts, 15, 13)) ->key : Symbol(key, Decl(complex.d.ts, 17, 33)) ->iter : Symbol(iter, Decl(complex.d.ts, 17, 44)) ->Ara : Symbol(Ara, Decl(complex.d.ts, 0, 0)) ->M : Symbol(M, Decl(complex.d.ts, 17, 12)) ->context : Symbol(context, Decl(complex.d.ts, 17, 67)) ->N2 : Symbol(N2, Decl(complex.d.ts, 14, 1)) ->M : Symbol(M, Decl(complex.d.ts, 17, 12)) +>flatMap : Symbol(N2.flatMap, Decl(complex.ts, 16, 66)) +>M : Symbol(M, Decl(complex.ts, 17, 12)) +>mapper : Symbol(mapper, Decl(complex.ts, 17, 15)) +>value : Symbol(value, Decl(complex.ts, 17, 24)) +>T : Symbol(T, Decl(complex.ts, 15, 13)) +>key : Symbol(key, Decl(complex.ts, 17, 33)) +>iter : Symbol(iter, Decl(complex.ts, 17, 44)) +>Ara : Symbol(Ara, Decl(complex.ts, 0, 0)) +>M : Symbol(M, Decl(complex.ts, 17, 12)) +>context : Symbol(context, Decl(complex.ts, 17, 67)) +>N2 : Symbol(N2, Decl(complex.ts, 14, 1)) +>M : Symbol(M, Decl(complex.ts, 17, 12)) toSeq(): N2; ->toSeq : Symbol(N2.toSeq, Decl(complex.d.ts, 17, 90)) ->N2 : Symbol(N2, Decl(complex.d.ts, 14, 1)) ->T : Symbol(T, Decl(complex.d.ts, 15, 13)) +>toSeq : Symbol(N2.toSeq, Decl(complex.ts, 17, 90)) +>N2 : Symbol(N2, Decl(complex.ts, 14, 1)) +>T : Symbol(T, Decl(complex.ts, 15, 13)) } -=== tests/cases/compiler/immutable.d.ts === +=== tests/cases/compiler/immutable.ts === // Test that complex recursive collections can pass the `extends` assignability check without // running out of memory. This bug was exposed in Typescript 2.4 when more generic signatures // started being checked. declare module Immutable { ->Immutable : Symbol(Immutable, Decl(immutable.d.ts, 0, 0)) +>Immutable : Symbol(Immutable, Decl(immutable.ts, 0, 0)) export function fromJS(jsValue: any, reviver?: (key: string | number, sequence: Collection.Keyed | Collection.Indexed, path?: Array) => any): any; ->fromJS : Symbol(fromJS, Decl(immutable.d.ts, 3, 26)) ->jsValue : Symbol(jsValue, Decl(immutable.d.ts, 4, 25)) ->reviver : Symbol(reviver, Decl(immutable.d.ts, 4, 38)) ->key : Symbol(key, Decl(immutable.d.ts, 4, 50)) ->sequence : Symbol(sequence, Decl(immutable.d.ts, 4, 71)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Collection.Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->path : Symbol(path, Decl(immutable.d.ts, 4, 138)) +>fromJS : Symbol(fromJS, Decl(immutable.ts, 3, 26)) +>jsValue : Symbol(jsValue, Decl(immutable.ts, 4, 25)) +>reviver : Symbol(reviver, Decl(immutable.ts, 4, 38)) +>key : Symbol(key, Decl(immutable.ts, 4, 50)) +>sequence : Symbol(sequence, Decl(immutable.ts, 4, 71)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Collection.Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>path : Symbol(path, Decl(immutable.ts, 4, 138)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) export function is(first: any, second: any): boolean; ->is : Symbol(is, Decl(immutable.d.ts, 4, 183)) ->first : Symbol(first, Decl(immutable.d.ts, 5, 21)) ->second : Symbol(second, Decl(immutable.d.ts, 5, 32)) +>is : Symbol(is, Decl(immutable.ts, 4, 183)) +>first : Symbol(first, Decl(immutable.ts, 5, 21)) +>second : Symbol(second, Decl(immutable.ts, 5, 32)) export function hash(value: any): number; ->hash : Symbol(hash, Decl(immutable.d.ts, 5, 55)) ->value : Symbol(value, Decl(immutable.d.ts, 6, 23)) +>hash : Symbol(hash, Decl(immutable.ts, 5, 55)) +>value : Symbol(value, Decl(immutable.ts, 6, 23)) export function isImmutable(maybeImmutable: any): maybeImmutable is Collection; ->isImmutable : Symbol(isImmutable, Decl(immutable.d.ts, 6, 43)) ->maybeImmutable : Symbol(maybeImmutable, Decl(immutable.d.ts, 7, 30)) ->maybeImmutable : Symbol(maybeImmutable, Decl(immutable.d.ts, 7, 30)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) +>isImmutable : Symbol(isImmutable, Decl(immutable.ts, 6, 43)) +>maybeImmutable : Symbol(maybeImmutable, Decl(immutable.ts, 7, 30)) +>maybeImmutable : Symbol(maybeImmutable, Decl(immutable.ts, 7, 30)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) export function isCollection(maybeCollection: any): maybeCollection is Collection; ->isCollection : Symbol(isCollection, Decl(immutable.d.ts, 7, 91)) ->maybeCollection : Symbol(maybeCollection, Decl(immutable.d.ts, 8, 31)) ->maybeCollection : Symbol(maybeCollection, Decl(immutable.d.ts, 8, 31)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) +>isCollection : Symbol(isCollection, Decl(immutable.ts, 7, 91)) +>maybeCollection : Symbol(maybeCollection, Decl(immutable.ts, 8, 31)) +>maybeCollection : Symbol(maybeCollection, Decl(immutable.ts, 8, 31)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) export function isKeyed(maybeKeyed: any): maybeKeyed is Collection.Keyed; ->isKeyed : Symbol(isKeyed, Decl(immutable.d.ts, 8, 94)) ->maybeKeyed : Symbol(maybeKeyed, Decl(immutable.d.ts, 9, 26)) ->maybeKeyed : Symbol(maybeKeyed, Decl(immutable.d.ts, 9, 26)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Collection.Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) +>isKeyed : Symbol(isKeyed, Decl(immutable.ts, 8, 94)) +>maybeKeyed : Symbol(maybeKeyed, Decl(immutable.ts, 9, 26)) +>maybeKeyed : Symbol(maybeKeyed, Decl(immutable.ts, 9, 26)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Collection.Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) export function isIndexed(maybeIndexed: any): maybeIndexed is Collection.Indexed; ->isIndexed : Symbol(isIndexed, Decl(immutable.d.ts, 9, 85)) ->maybeIndexed : Symbol(maybeIndexed, Decl(immutable.d.ts, 10, 28)) ->maybeIndexed : Symbol(maybeIndexed, Decl(immutable.d.ts, 10, 28)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) +>isIndexed : Symbol(isIndexed, Decl(immutable.ts, 9, 85)) +>maybeIndexed : Symbol(maybeIndexed, Decl(immutable.ts, 10, 28)) +>maybeIndexed : Symbol(maybeIndexed, Decl(immutable.ts, 10, 28)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) export function isAssociative(maybeAssociative: any): maybeAssociative is Collection.Keyed | Collection.Indexed; ->isAssociative : Symbol(isAssociative, Decl(immutable.d.ts, 10, 88)) ->maybeAssociative : Symbol(maybeAssociative, Decl(immutable.d.ts, 11, 32)) ->maybeAssociative : Symbol(maybeAssociative, Decl(immutable.d.ts, 11, 32)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Collection.Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) +>isAssociative : Symbol(isAssociative, Decl(immutable.ts, 10, 88)) +>maybeAssociative : Symbol(maybeAssociative, Decl(immutable.ts, 11, 32)) +>maybeAssociative : Symbol(maybeAssociative, Decl(immutable.ts, 11, 32)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Collection.Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) export function isOrdered(maybeOrdered: any): boolean; ->isOrdered : Symbol(isOrdered, Decl(immutable.d.ts, 11, 129)) ->maybeOrdered : Symbol(maybeOrdered, Decl(immutable.d.ts, 12, 28)) +>isOrdered : Symbol(isOrdered, Decl(immutable.ts, 11, 129)) +>maybeOrdered : Symbol(maybeOrdered, Decl(immutable.ts, 12, 28)) export function isValueObject(maybeValue: any): maybeValue is ValueObject; ->isValueObject : Symbol(isValueObject, Decl(immutable.d.ts, 12, 56)) ->maybeValue : Symbol(maybeValue, Decl(immutable.d.ts, 13, 32)) ->maybeValue : Symbol(maybeValue, Decl(immutable.d.ts, 13, 32)) ->ValueObject : Symbol(ValueObject, Decl(immutable.d.ts, 13, 76)) +>isValueObject : Symbol(isValueObject, Decl(immutable.ts, 12, 56)) +>maybeValue : Symbol(maybeValue, Decl(immutable.ts, 13, 32)) +>maybeValue : Symbol(maybeValue, Decl(immutable.ts, 13, 32)) +>ValueObject : Symbol(ValueObject, Decl(immutable.ts, 13, 76)) export interface ValueObject { ->ValueObject : Symbol(ValueObject, Decl(immutable.d.ts, 13, 76)) +>ValueObject : Symbol(ValueObject, Decl(immutable.ts, 13, 76)) equals(other: any): boolean; ->equals : Symbol(ValueObject.equals, Decl(immutable.d.ts, 14, 32)) ->other : Symbol(other, Decl(immutable.d.ts, 15, 11)) +>equals : Symbol(ValueObject.equals, Decl(immutable.ts, 14, 32)) +>other : Symbol(other, Decl(immutable.ts, 15, 11)) hashCode(): number; ->hashCode : Symbol(ValueObject.hashCode, Decl(immutable.d.ts, 15, 32)) +>hashCode : Symbol(ValueObject.hashCode, Decl(immutable.ts, 15, 32)) } export module List { ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) function isList(maybeList: any): maybeList is List; ->isList : Symbol(isList, Decl(immutable.d.ts, 18, 22)) ->maybeList : Symbol(maybeList, Decl(immutable.d.ts, 19, 20)) ->maybeList : Symbol(maybeList, Decl(immutable.d.ts, 19, 20)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) +>isList : Symbol(isList, Decl(immutable.ts, 18, 22)) +>maybeList : Symbol(maybeList, Decl(immutable.ts, 19, 20)) +>maybeList : Symbol(maybeList, Decl(immutable.ts, 19, 20)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) function of(...values: Array): List; ->of : Symbol(of, Decl(immutable.d.ts, 19, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 20, 16)) ->values : Symbol(values, Decl(immutable.d.ts, 20, 19)) +>of : Symbol(of, Decl(immutable.ts, 19, 60)) +>T : Symbol(T, Decl(immutable.ts, 20, 16)) +>values : Symbol(values, Decl(immutable.ts, 20, 19)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 20, 16)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 20, 16)) +>T : Symbol(T, Decl(immutable.ts, 20, 16)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 20, 16)) } export function List(): List; ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) export function List(): List; ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 23, 23)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 23, 23)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 23, 23)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 23, 23)) export function List(collection: Iterable): List; ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 24, 23)) ->collection : Symbol(collection, Decl(immutable.d.ts, 24, 26)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 24, 23)) +>collection : Symbol(collection, Decl(immutable.ts, 24, 26)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 24, 23)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 24, 23)) +>T : Symbol(T, Decl(immutable.ts, 24, 23)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 24, 23)) export interface List extends Collection.Indexed { ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->Collection.Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>Collection.Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) // Persistent changes set(index: number, value: T): List; ->set : Symbol(List.set, Decl(immutable.d.ts, 25, 58)) ->index : Symbol(index, Decl(immutable.d.ts, 27, 8)) ->value : Symbol(value, Decl(immutable.d.ts, 27, 22)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>set : Symbol(List.set, Decl(immutable.ts, 25, 58)) +>index : Symbol(index, Decl(immutable.ts, 27, 8)) +>value : Symbol(value, Decl(immutable.ts, 27, 22)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) delete(index: number): List; ->delete : Symbol(List.delete, Decl(immutable.d.ts, 27, 42)) ->index : Symbol(index, Decl(immutable.d.ts, 28, 11)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>delete : Symbol(List.delete, Decl(immutable.ts, 27, 42)) +>index : Symbol(index, Decl(immutable.ts, 28, 11)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) remove(index: number): List; ->remove : Symbol(List.remove, Decl(immutable.d.ts, 28, 35)) ->index : Symbol(index, Decl(immutable.d.ts, 29, 11)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>remove : Symbol(List.remove, Decl(immutable.ts, 28, 35)) +>index : Symbol(index, Decl(immutable.ts, 29, 11)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) insert(index: number, value: T): List; ->insert : Symbol(List.insert, Decl(immutable.d.ts, 29, 35)) ->index : Symbol(index, Decl(immutable.d.ts, 30, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 30, 25)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>insert : Symbol(List.insert, Decl(immutable.ts, 29, 35)) +>index : Symbol(index, Decl(immutable.ts, 30, 11)) +>value : Symbol(value, Decl(immutable.ts, 30, 25)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) clear(): List; ->clear : Symbol(List.clear, Decl(immutable.d.ts, 30, 45)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>clear : Symbol(List.clear, Decl(immutable.ts, 30, 45)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) push(...values: Array): List; ->push : Symbol(List.push, Decl(immutable.d.ts, 31, 21)) ->values : Symbol(values, Decl(immutable.d.ts, 32, 9)) +>push : Symbol(List.push, Decl(immutable.ts, 31, 21)) +>values : Symbol(values, Decl(immutable.ts, 32, 9)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) pop(): List; ->pop : Symbol(List.pop, Decl(immutable.d.ts, 32, 39)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>pop : Symbol(List.pop, Decl(immutable.ts, 32, 39)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) unshift(...values: Array): List; ->unshift : Symbol(List.unshift, Decl(immutable.d.ts, 33, 19)) ->values : Symbol(values, Decl(immutable.d.ts, 34, 12)) +>unshift : Symbol(List.unshift, Decl(immutable.ts, 33, 19)) +>values : Symbol(values, Decl(immutable.ts, 34, 12)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) shift(): List; ->shift : Symbol(List.shift, Decl(immutable.d.ts, 34, 42)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>shift : Symbol(List.shift, Decl(immutable.ts, 34, 42)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) update(index: number, notSetValue: T, updater: (value: T) => T): this; ->update : Symbol(List.update, Decl(immutable.d.ts, 35, 21), Decl(immutable.d.ts, 36, 74), Decl(immutable.d.ts, 37, 58)) ->index : Symbol(index, Decl(immutable.d.ts, 36, 11)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 36, 25)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->updater : Symbol(updater, Decl(immutable.d.ts, 36, 41)) ->value : Symbol(value, Decl(immutable.d.ts, 36, 52)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>update : Symbol(List.update, Decl(immutable.ts, 35, 21), Decl(immutable.ts, 36, 74), Decl(immutable.ts, 37, 58)) +>index : Symbol(index, Decl(immutable.ts, 36, 11)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 36, 25)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>updater : Symbol(updater, Decl(immutable.ts, 36, 41)) +>value : Symbol(value, Decl(immutable.ts, 36, 52)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) update(index: number, updater: (value: T) => T): this; ->update : Symbol(List.update, Decl(immutable.d.ts, 35, 21), Decl(immutable.d.ts, 36, 74), Decl(immutable.d.ts, 37, 58)) ->index : Symbol(index, Decl(immutable.d.ts, 37, 11)) ->updater : Symbol(updater, Decl(immutable.d.ts, 37, 25)) ->value : Symbol(value, Decl(immutable.d.ts, 37, 36)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>update : Symbol(List.update, Decl(immutable.ts, 35, 21), Decl(immutable.ts, 36, 74), Decl(immutable.ts, 37, 58)) +>index : Symbol(index, Decl(immutable.ts, 37, 11)) +>updater : Symbol(updater, Decl(immutable.ts, 37, 25)) +>value : Symbol(value, Decl(immutable.ts, 37, 36)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) update(updater: (value: this) => R): R; ->update : Symbol(List.update, Decl(immutable.d.ts, 35, 21), Decl(immutable.d.ts, 36, 74), Decl(immutable.d.ts, 37, 58)) ->R : Symbol(R, Decl(immutable.d.ts, 38, 11)) ->updater : Symbol(updater, Decl(immutable.d.ts, 38, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 38, 24)) ->R : Symbol(R, Decl(immutable.d.ts, 38, 11)) ->R : Symbol(R, Decl(immutable.d.ts, 38, 11)) +>update : Symbol(List.update, Decl(immutable.ts, 35, 21), Decl(immutable.ts, 36, 74), Decl(immutable.ts, 37, 58)) +>R : Symbol(R, Decl(immutable.ts, 38, 11)) +>updater : Symbol(updater, Decl(immutable.ts, 38, 14)) +>value : Symbol(value, Decl(immutable.ts, 38, 24)) +>R : Symbol(R, Decl(immutable.ts, 38, 11)) +>R : Symbol(R, Decl(immutable.ts, 38, 11)) merge(...collections: Array | Array>): this; ->merge : Symbol(List.merge, Decl(immutable.d.ts, 38, 46)) ->collections : Symbol(collections, Decl(immutable.d.ts, 39, 10)) +>merge : Symbol(List.merge, Decl(immutable.ts, 38, 46)) +>collections : Symbol(collections, Decl(immutable.ts, 39, 10)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) mergeWith(merger: (oldVal: T, newVal: T, key: number) => T, ...collections: Array | Array>): this; ->mergeWith : Symbol(List.mergeWith, Decl(immutable.d.ts, 39, 73)) ->merger : Symbol(merger, Decl(immutable.d.ts, 40, 14)) ->oldVal : Symbol(oldVal, Decl(immutable.d.ts, 40, 23)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->newVal : Symbol(newVal, Decl(immutable.d.ts, 40, 33)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->key : Symbol(key, Decl(immutable.d.ts, 40, 44)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->collections : Symbol(collections, Decl(immutable.d.ts, 40, 63)) +>mergeWith : Symbol(List.mergeWith, Decl(immutable.ts, 39, 73)) +>merger : Symbol(merger, Decl(immutable.ts, 40, 14)) +>oldVal : Symbol(oldVal, Decl(immutable.ts, 40, 23)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>newVal : Symbol(newVal, Decl(immutable.ts, 40, 33)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>key : Symbol(key, Decl(immutable.ts, 40, 44)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>collections : Symbol(collections, Decl(immutable.ts, 40, 63)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) mergeDeep(...collections: Array | Array>): this; ->mergeDeep : Symbol(List.mergeDeep, Decl(immutable.d.ts, 40, 127)) ->collections : Symbol(collections, Decl(immutable.d.ts, 41, 14)) +>mergeDeep : Symbol(List.mergeDeep, Decl(immutable.ts, 40, 127)) +>collections : Symbol(collections, Decl(immutable.ts, 41, 14)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) mergeDeepWith(merger: (oldVal: T, newVal: T, key: number) => T, ...collections: Array | Array>): this; ->mergeDeepWith : Symbol(List.mergeDeepWith, Decl(immutable.d.ts, 41, 77)) ->merger : Symbol(merger, Decl(immutable.d.ts, 42, 18)) ->oldVal : Symbol(oldVal, Decl(immutable.d.ts, 42, 27)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->newVal : Symbol(newVal, Decl(immutable.d.ts, 42, 37)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->key : Symbol(key, Decl(immutable.d.ts, 42, 48)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->collections : Symbol(collections, Decl(immutable.d.ts, 42, 67)) +>mergeDeepWith : Symbol(List.mergeDeepWith, Decl(immutable.ts, 41, 77)) +>merger : Symbol(merger, Decl(immutable.ts, 42, 18)) +>oldVal : Symbol(oldVal, Decl(immutable.ts, 42, 27)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>newVal : Symbol(newVal, Decl(immutable.ts, 42, 37)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>key : Symbol(key, Decl(immutable.ts, 42, 48)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>collections : Symbol(collections, Decl(immutable.ts, 42, 67)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) setSize(size: number): List; ->setSize : Symbol(List.setSize, Decl(immutable.d.ts, 42, 131)) ->size : Symbol(size, Decl(immutable.d.ts, 43, 12)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) +>setSize : Symbol(List.setSize, Decl(immutable.ts, 42, 131)) +>size : Symbol(size, Decl(immutable.ts, 43, 12)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) // Deep persistent changes setIn(keyPath: Iterable, value: any): this; ->setIn : Symbol(List.setIn, Decl(immutable.d.ts, 43, 35)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 45, 10)) +>setIn : Symbol(List.setIn, Decl(immutable.ts, 43, 35)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 45, 10)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->value : Symbol(value, Decl(immutable.d.ts, 45, 33)) +>value : Symbol(value, Decl(immutable.ts, 45, 33)) deleteIn(keyPath: Iterable): this; ->deleteIn : Symbol(List.deleteIn, Decl(immutable.d.ts, 45, 52)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 46, 13)) +>deleteIn : Symbol(List.deleteIn, Decl(immutable.ts, 45, 52)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 46, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) removeIn(keyPath: Iterable): this; ->removeIn : Symbol(List.removeIn, Decl(immutable.d.ts, 46, 43)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 47, 13)) +>removeIn : Symbol(List.removeIn, Decl(immutable.ts, 46, 43)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 47, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) updateIn(keyPath: Iterable, notSetValue: any, updater: (value: any) => any): this; ->updateIn : Symbol(List.updateIn, Decl(immutable.d.ts, 47, 43), Decl(immutable.d.ts, 48, 91)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 48, 13)) +>updateIn : Symbol(List.updateIn, Decl(immutable.ts, 47, 43), Decl(immutable.ts, 48, 91)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 48, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 48, 36)) ->updater : Symbol(updater, Decl(immutable.d.ts, 48, 54)) ->value : Symbol(value, Decl(immutable.d.ts, 48, 65)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 48, 36)) +>updater : Symbol(updater, Decl(immutable.ts, 48, 54)) +>value : Symbol(value, Decl(immutable.ts, 48, 65)) updateIn(keyPath: Iterable, updater: (value: any) => any): this; ->updateIn : Symbol(List.updateIn, Decl(immutable.d.ts, 47, 43), Decl(immutable.d.ts, 48, 91)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 49, 13)) +>updateIn : Symbol(List.updateIn, Decl(immutable.ts, 47, 43), Decl(immutable.ts, 48, 91)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 49, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->updater : Symbol(updater, Decl(immutable.d.ts, 49, 36)) ->value : Symbol(value, Decl(immutable.d.ts, 49, 47)) +>updater : Symbol(updater, Decl(immutable.ts, 49, 36)) +>value : Symbol(value, Decl(immutable.ts, 49, 47)) mergeIn(keyPath: Iterable, ...collections: Array): this; ->mergeIn : Symbol(List.mergeIn, Decl(immutable.d.ts, 49, 73)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 50, 12)) +>mergeIn : Symbol(List.mergeIn, Decl(immutable.ts, 49, 73)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 50, 12)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->collections : Symbol(collections, Decl(immutable.d.ts, 50, 35)) +>collections : Symbol(collections, Decl(immutable.ts, 50, 35)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) mergeDeepIn(keyPath: Iterable, ...collections: Array): this; ->mergeDeepIn : Symbol(List.mergeDeepIn, Decl(immutable.d.ts, 50, 70)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 51, 16)) +>mergeDeepIn : Symbol(List.mergeDeepIn, Decl(immutable.ts, 50, 70)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 51, 16)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->collections : Symbol(collections, Decl(immutable.d.ts, 51, 39)) +>collections : Symbol(collections, Decl(immutable.ts, 51, 39)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) // Transient changes withMutations(mutator: (mutable: this) => any): this; ->withMutations : Symbol(List.withMutations, Decl(immutable.d.ts, 51, 74)) ->mutator : Symbol(mutator, Decl(immutable.d.ts, 53, 18)) ->mutable : Symbol(mutable, Decl(immutable.d.ts, 53, 28)) +>withMutations : Symbol(List.withMutations, Decl(immutable.ts, 51, 74)) +>mutator : Symbol(mutator, Decl(immutable.ts, 53, 18)) +>mutable : Symbol(mutable, Decl(immutable.ts, 53, 28)) asMutable(): this; ->asMutable : Symbol(List.asMutable, Decl(immutable.d.ts, 53, 57)) +>asMutable : Symbol(List.asMutable, Decl(immutable.ts, 53, 57)) asImmutable(): this; ->asImmutable : Symbol(List.asImmutable, Decl(immutable.d.ts, 54, 22)) +>asImmutable : Symbol(List.asImmutable, Decl(immutable.ts, 54, 22)) // Sequence algorithms concat(...valuesOrCollections: Array | C>): List; ->concat : Symbol(List.concat, Decl(immutable.d.ts, 55, 24)) ->C : Symbol(C, Decl(immutable.d.ts, 57, 11)) ->valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.d.ts, 57, 14)) +>concat : Symbol(List.concat, Decl(immutable.ts, 55, 24)) +>C : Symbol(C, Decl(immutable.ts, 57, 11)) +>valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.ts, 57, 14)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->C : Symbol(C, Decl(immutable.d.ts, 57, 11)) ->C : Symbol(C, Decl(immutable.d.ts, 57, 11)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->C : Symbol(C, Decl(immutable.d.ts, 57, 11)) +>C : Symbol(C, Decl(immutable.ts, 57, 11)) +>C : Symbol(C, Decl(immutable.ts, 57, 11)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>C : Symbol(C, Decl(immutable.ts, 57, 11)) map(mapper: (value: T, key: number, iter: this) => M, context?: any): List; ->map : Symbol(List.map, Decl(immutable.d.ts, 57, 75)) ->M : Symbol(M, Decl(immutable.d.ts, 58, 8)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 58, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 58, 20)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->key : Symbol(key, Decl(immutable.d.ts, 58, 29)) ->iter : Symbol(iter, Decl(immutable.d.ts, 58, 42)) ->M : Symbol(M, Decl(immutable.d.ts, 58, 8)) ->context : Symbol(context, Decl(immutable.d.ts, 58, 60)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->M : Symbol(M, Decl(immutable.d.ts, 58, 8)) +>map : Symbol(List.map, Decl(immutable.ts, 57, 75)) +>M : Symbol(M, Decl(immutable.ts, 58, 8)) +>mapper : Symbol(mapper, Decl(immutable.ts, 58, 11)) +>value : Symbol(value, Decl(immutable.ts, 58, 20)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>key : Symbol(key, Decl(immutable.ts, 58, 29)) +>iter : Symbol(iter, Decl(immutable.ts, 58, 42)) +>M : Symbol(M, Decl(immutable.ts, 58, 8)) +>context : Symbol(context, Decl(immutable.ts, 58, 60)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>M : Symbol(M, Decl(immutable.ts, 58, 8)) flatMap(mapper: (value: T, key: number, iter: this) => Iterable, context?: any): List; ->flatMap : Symbol(List.flatMap, Decl(immutable.d.ts, 58, 85)) ->M : Symbol(M, Decl(immutable.d.ts, 59, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 59, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 59, 24)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->key : Symbol(key, Decl(immutable.d.ts, 59, 33)) ->iter : Symbol(iter, Decl(immutable.d.ts, 59, 46)) +>flatMap : Symbol(List.flatMap, Decl(immutable.ts, 58, 85)) +>M : Symbol(M, Decl(immutable.ts, 59, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 59, 15)) +>value : Symbol(value, Decl(immutable.ts, 59, 24)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>key : Symbol(key, Decl(immutable.ts, 59, 33)) +>iter : Symbol(iter, Decl(immutable.ts, 59, 46)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 59, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 59, 74)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->M : Symbol(M, Decl(immutable.d.ts, 59, 12)) +>M : Symbol(M, Decl(immutable.ts, 59, 12)) +>context : Symbol(context, Decl(immutable.ts, 59, 74)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>M : Symbol(M, Decl(immutable.ts, 59, 12)) filter(predicate: (value: T, index: number, iter: this) => value is F, context?: any): List; ->filter : Symbol(List.filter, Decl(immutable.d.ts, 59, 99), Decl(immutable.d.ts, 60, 112)) ->F : Symbol(F, Decl(immutable.d.ts, 60, 11)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 60, 24)) ->value : Symbol(value, Decl(immutable.d.ts, 60, 36)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->index : Symbol(index, Decl(immutable.d.ts, 60, 45)) ->iter : Symbol(iter, Decl(immutable.d.ts, 60, 60)) ->value : Symbol(value, Decl(immutable.d.ts, 60, 36)) ->F : Symbol(F, Decl(immutable.d.ts, 60, 11)) ->context : Symbol(context, Decl(immutable.d.ts, 60, 87)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->F : Symbol(F, Decl(immutable.d.ts, 60, 11)) +>filter : Symbol(List.filter, Decl(immutable.ts, 59, 99), Decl(immutable.ts, 60, 112)) +>F : Symbol(F, Decl(immutable.ts, 60, 11)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>predicate : Symbol(predicate, Decl(immutable.ts, 60, 24)) +>value : Symbol(value, Decl(immutable.ts, 60, 36)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>index : Symbol(index, Decl(immutable.ts, 60, 45)) +>iter : Symbol(iter, Decl(immutable.ts, 60, 60)) +>value : Symbol(value, Decl(immutable.ts, 60, 36)) +>F : Symbol(F, Decl(immutable.ts, 60, 11)) +>context : Symbol(context, Decl(immutable.ts, 60, 87)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>F : Symbol(F, Decl(immutable.ts, 60, 11)) filter(predicate: (value: T, index: number, iter: this) => any, context?: any): this; ->filter : Symbol(List.filter, Decl(immutable.d.ts, 59, 99), Decl(immutable.d.ts, 60, 112)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 61, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 61, 23)) ->T : Symbol(T, Decl(immutable.d.ts, 25, 24)) ->index : Symbol(index, Decl(immutable.d.ts, 61, 32)) ->iter : Symbol(iter, Decl(immutable.d.ts, 61, 47)) ->context : Symbol(context, Decl(immutable.d.ts, 61, 67)) +>filter : Symbol(List.filter, Decl(immutable.ts, 59, 99), Decl(immutable.ts, 60, 112)) +>predicate : Symbol(predicate, Decl(immutable.ts, 61, 11)) +>value : Symbol(value, Decl(immutable.ts, 61, 23)) +>T : Symbol(T, Decl(immutable.ts, 25, 24)) +>index : Symbol(index, Decl(immutable.ts, 61, 32)) +>iter : Symbol(iter, Decl(immutable.ts, 61, 47)) +>context : Symbol(context, Decl(immutable.ts, 61, 67)) } export module Map { ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) function isMap(maybeMap: any): maybeMap is Map; ->isMap : Symbol(isMap, Decl(immutable.d.ts, 63, 21)) ->maybeMap : Symbol(maybeMap, Decl(immutable.d.ts, 64, 19)) ->maybeMap : Symbol(maybeMap, Decl(immutable.d.ts, 64, 19)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) +>isMap : Symbol(isMap, Decl(immutable.ts, 63, 21)) +>maybeMap : Symbol(maybeMap, Decl(immutable.ts, 64, 19)) +>maybeMap : Symbol(maybeMap, Decl(immutable.ts, 64, 19)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) function of(...keyValues: Array): Map; ->of : Symbol(of, Decl(immutable.d.ts, 64, 61)) ->keyValues : Symbol(keyValues, Decl(immutable.d.ts, 65, 16)) +>of : Symbol(of, Decl(immutable.ts, 64, 61)) +>keyValues : Symbol(keyValues, Decl(immutable.ts, 65, 16)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) } export function Map(collection: Iterable<[K, V]>): Map; ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 67, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 67, 24)) ->collection : Symbol(collection, Decl(immutable.d.ts, 67, 28)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 67, 22)) +>V : Symbol(V, Decl(immutable.ts, 67, 24)) +>collection : Symbol(collection, Decl(immutable.ts, 67, 28)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->K : Symbol(K, Decl(immutable.d.ts, 67, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 67, 24)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 67, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 67, 24)) +>K : Symbol(K, Decl(immutable.ts, 67, 22)) +>V : Symbol(V, Decl(immutable.ts, 67, 24)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 67, 22)) +>V : Symbol(V, Decl(immutable.ts, 67, 24)) export function Map(collection: Iterable>): Map; ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->T : Symbol(T, Decl(immutable.d.ts, 68, 22)) ->collection : Symbol(collection, Decl(immutable.d.ts, 68, 25)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>T : Symbol(T, Decl(immutable.ts, 68, 22)) +>collection : Symbol(collection, Decl(immutable.ts, 68, 25)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 68, 22)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->T : Symbol(T, Decl(immutable.d.ts, 68, 22)) ->T : Symbol(T, Decl(immutable.d.ts, 68, 22)) +>T : Symbol(T, Decl(immutable.ts, 68, 22)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>T : Symbol(T, Decl(immutable.ts, 68, 22)) +>T : Symbol(T, Decl(immutable.ts, 68, 22)) export function Map(obj: {[key: string]: V}): Map; ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->V : Symbol(V, Decl(immutable.d.ts, 69, 22)) ->obj : Symbol(obj, Decl(immutable.d.ts, 69, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 69, 32)) ->V : Symbol(V, Decl(immutable.d.ts, 69, 22)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->V : Symbol(V, Decl(immutable.d.ts, 69, 22)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>V : Symbol(V, Decl(immutable.ts, 69, 22)) +>obj : Symbol(obj, Decl(immutable.ts, 69, 25)) +>key : Symbol(key, Decl(immutable.ts, 69, 32)) +>V : Symbol(V, Decl(immutable.ts, 69, 22)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>V : Symbol(V, Decl(immutable.ts, 69, 22)) export function Map(): Map; ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 70, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 70, 24)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 70, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 70, 24)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 70, 22)) +>V : Symbol(V, Decl(immutable.ts, 70, 24)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 70, 22)) +>V : Symbol(V, Decl(immutable.ts, 70, 24)) export function Map(): Map; ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) export interface Map extends Collection.Keyed { ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->Collection.Keyed : Symbol(Collection.Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Collection.Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>Collection.Keyed : Symbol(Collection.Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Collection.Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) // Persistent changes set(key: K, value: V): this; ->set : Symbol(Map.set, Decl(immutable.d.ts, 72, 61)) ->key : Symbol(key, Decl(immutable.d.ts, 74, 8)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->value : Symbol(value, Decl(immutable.d.ts, 74, 15)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) +>set : Symbol(Map.set, Decl(immutable.ts, 72, 61)) +>key : Symbol(key, Decl(immutable.ts, 74, 8)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>value : Symbol(value, Decl(immutable.ts, 74, 15)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) delete(key: K): this; ->delete : Symbol(Map.delete, Decl(immutable.d.ts, 74, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 75, 11)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) +>delete : Symbol(Map.delete, Decl(immutable.ts, 74, 32)) +>key : Symbol(key, Decl(immutable.ts, 75, 11)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) remove(key: K): this; ->remove : Symbol(Map.remove, Decl(immutable.d.ts, 75, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 76, 11)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) +>remove : Symbol(Map.remove, Decl(immutable.ts, 75, 25)) +>key : Symbol(key, Decl(immutable.ts, 76, 11)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) deleteAll(keys: Iterable): this; ->deleteAll : Symbol(Map.deleteAll, Decl(immutable.d.ts, 76, 25)) ->keys : Symbol(keys, Decl(immutable.d.ts, 77, 14)) +>deleteAll : Symbol(Map.deleteAll, Decl(immutable.ts, 76, 25)) +>keys : Symbol(keys, Decl(immutable.ts, 77, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) removeAll(keys: Iterable): this; ->removeAll : Symbol(Map.removeAll, Decl(immutable.d.ts, 77, 39)) ->keys : Symbol(keys, Decl(immutable.d.ts, 78, 14)) +>removeAll : Symbol(Map.removeAll, Decl(immutable.ts, 77, 39)) +>keys : Symbol(keys, Decl(immutable.ts, 78, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) clear(): this; ->clear : Symbol(Map.clear, Decl(immutable.d.ts, 78, 39)) +>clear : Symbol(Map.clear, Decl(immutable.ts, 78, 39)) update(key: K, notSetValue: V, updater: (value: V) => V): this; ->update : Symbol(Map.update, Decl(immutable.d.ts, 79, 18), Decl(immutable.d.ts, 80, 67), Decl(immutable.d.ts, 81, 51)) ->key : Symbol(key, Decl(immutable.d.ts, 80, 11)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 80, 18)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->updater : Symbol(updater, Decl(immutable.d.ts, 80, 34)) ->value : Symbol(value, Decl(immutable.d.ts, 80, 45)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) +>update : Symbol(Map.update, Decl(immutable.ts, 79, 18), Decl(immutable.ts, 80, 67), Decl(immutable.ts, 81, 51)) +>key : Symbol(key, Decl(immutable.ts, 80, 11)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 80, 18)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>updater : Symbol(updater, Decl(immutable.ts, 80, 34)) +>value : Symbol(value, Decl(immutable.ts, 80, 45)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) update(key: K, updater: (value: V) => V): this; ->update : Symbol(Map.update, Decl(immutable.d.ts, 79, 18), Decl(immutable.d.ts, 80, 67), Decl(immutable.d.ts, 81, 51)) ->key : Symbol(key, Decl(immutable.d.ts, 81, 11)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->updater : Symbol(updater, Decl(immutable.d.ts, 81, 18)) ->value : Symbol(value, Decl(immutable.d.ts, 81, 29)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) +>update : Symbol(Map.update, Decl(immutable.ts, 79, 18), Decl(immutable.ts, 80, 67), Decl(immutable.ts, 81, 51)) +>key : Symbol(key, Decl(immutable.ts, 81, 11)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>updater : Symbol(updater, Decl(immutable.ts, 81, 18)) +>value : Symbol(value, Decl(immutable.ts, 81, 29)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) update(updater: (value: this) => R): R; ->update : Symbol(Map.update, Decl(immutable.d.ts, 79, 18), Decl(immutable.d.ts, 80, 67), Decl(immutable.d.ts, 81, 51)) ->R : Symbol(R, Decl(immutable.d.ts, 82, 11)) ->updater : Symbol(updater, Decl(immutable.d.ts, 82, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 82, 24)) ->R : Symbol(R, Decl(immutable.d.ts, 82, 11)) ->R : Symbol(R, Decl(immutable.d.ts, 82, 11)) +>update : Symbol(Map.update, Decl(immutable.ts, 79, 18), Decl(immutable.ts, 80, 67), Decl(immutable.ts, 81, 51)) +>R : Symbol(R, Decl(immutable.ts, 82, 11)) +>updater : Symbol(updater, Decl(immutable.ts, 82, 14)) +>value : Symbol(value, Decl(immutable.ts, 82, 24)) +>R : Symbol(R, Decl(immutable.ts, 82, 11)) +>R : Symbol(R, Decl(immutable.ts, 82, 11)) merge(...collections: Array | {[key: string]: V}>): this; ->merge : Symbol(Map.merge, Decl(immutable.d.ts, 82, 46)) ->collections : Symbol(collections, Decl(immutable.d.ts, 83, 10)) +>merge : Symbol(Map.merge, Decl(immutable.ts, 82, 46)) +>collections : Symbol(collections, Decl(immutable.ts, 83, 10)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 83, 53)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 83, 53)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) mergeWith(merger: (oldVal: V, newVal: V, key: K) => V, ...collections: Array | {[key: string]: V}>): this; ->mergeWith : Symbol(Map.mergeWith, Decl(immutable.d.ts, 83, 78)) ->merger : Symbol(merger, Decl(immutable.d.ts, 84, 14)) ->oldVal : Symbol(oldVal, Decl(immutable.d.ts, 84, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->newVal : Symbol(newVal, Decl(immutable.d.ts, 84, 33)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 84, 44)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->collections : Symbol(collections, Decl(immutable.d.ts, 84, 58)) +>mergeWith : Symbol(Map.mergeWith, Decl(immutable.ts, 83, 78)) +>merger : Symbol(merger, Decl(immutable.ts, 84, 14)) +>oldVal : Symbol(oldVal, Decl(immutable.ts, 84, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>newVal : Symbol(newVal, Decl(immutable.ts, 84, 33)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 84, 44)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>collections : Symbol(collections, Decl(immutable.ts, 84, 58)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 84, 102)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 84, 102)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) mergeDeep(...collections: Array | {[key: string]: V}>): this; ->mergeDeep : Symbol(Map.mergeDeep, Decl(immutable.d.ts, 84, 127)) ->collections : Symbol(collections, Decl(immutable.d.ts, 85, 14)) +>mergeDeep : Symbol(Map.mergeDeep, Decl(immutable.ts, 84, 127)) +>collections : Symbol(collections, Decl(immutable.ts, 85, 14)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 85, 57)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 85, 57)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) mergeDeepWith(merger: (oldVal: V, newVal: V, key: K) => V, ...collections: Array | {[key: string]: V}>): this; ->mergeDeepWith : Symbol(Map.mergeDeepWith, Decl(immutable.d.ts, 85, 82)) ->merger : Symbol(merger, Decl(immutable.d.ts, 86, 18)) ->oldVal : Symbol(oldVal, Decl(immutable.d.ts, 86, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->newVal : Symbol(newVal, Decl(immutable.d.ts, 86, 37)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 86, 48)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->collections : Symbol(collections, Decl(immutable.d.ts, 86, 62)) +>mergeDeepWith : Symbol(Map.mergeDeepWith, Decl(immutable.ts, 85, 82)) +>merger : Symbol(merger, Decl(immutable.ts, 86, 18)) +>oldVal : Symbol(oldVal, Decl(immutable.ts, 86, 27)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>newVal : Symbol(newVal, Decl(immutable.ts, 86, 37)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 86, 48)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>collections : Symbol(collections, Decl(immutable.ts, 86, 62)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 86, 106)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 86, 106)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) // Deep persistent changes setIn(keyPath: Iterable, value: any): this; ->setIn : Symbol(Map.setIn, Decl(immutable.d.ts, 86, 131)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 88, 10)) +>setIn : Symbol(Map.setIn, Decl(immutable.ts, 86, 131)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 88, 10)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->value : Symbol(value, Decl(immutable.d.ts, 88, 33)) +>value : Symbol(value, Decl(immutable.ts, 88, 33)) deleteIn(keyPath: Iterable): this; ->deleteIn : Symbol(Map.deleteIn, Decl(immutable.d.ts, 88, 52)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 89, 13)) +>deleteIn : Symbol(Map.deleteIn, Decl(immutable.ts, 88, 52)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 89, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) removeIn(keyPath: Iterable): this; ->removeIn : Symbol(Map.removeIn, Decl(immutable.d.ts, 89, 43)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 90, 13)) +>removeIn : Symbol(Map.removeIn, Decl(immutable.ts, 89, 43)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 90, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) updateIn(keyPath: Iterable, notSetValue: any, updater: (value: any) => any): this; ->updateIn : Symbol(Map.updateIn, Decl(immutable.d.ts, 90, 43), Decl(immutable.d.ts, 91, 91)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 91, 13)) +>updateIn : Symbol(Map.updateIn, Decl(immutable.ts, 90, 43), Decl(immutable.ts, 91, 91)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 91, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 91, 36)) ->updater : Symbol(updater, Decl(immutable.d.ts, 91, 54)) ->value : Symbol(value, Decl(immutable.d.ts, 91, 65)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 91, 36)) +>updater : Symbol(updater, Decl(immutable.ts, 91, 54)) +>value : Symbol(value, Decl(immutable.ts, 91, 65)) updateIn(keyPath: Iterable, updater: (value: any) => any): this; ->updateIn : Symbol(Map.updateIn, Decl(immutable.d.ts, 90, 43), Decl(immutable.d.ts, 91, 91)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 92, 13)) +>updateIn : Symbol(Map.updateIn, Decl(immutable.ts, 90, 43), Decl(immutable.ts, 91, 91)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 92, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->updater : Symbol(updater, Decl(immutable.d.ts, 92, 36)) ->value : Symbol(value, Decl(immutable.d.ts, 92, 47)) +>updater : Symbol(updater, Decl(immutable.ts, 92, 36)) +>value : Symbol(value, Decl(immutable.ts, 92, 47)) mergeIn(keyPath: Iterable, ...collections: Array): this; ->mergeIn : Symbol(Map.mergeIn, Decl(immutable.d.ts, 92, 73)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 93, 12)) +>mergeIn : Symbol(Map.mergeIn, Decl(immutable.ts, 92, 73)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 93, 12)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->collections : Symbol(collections, Decl(immutable.d.ts, 93, 35)) +>collections : Symbol(collections, Decl(immutable.ts, 93, 35)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) mergeDeepIn(keyPath: Iterable, ...collections: Array): this; ->mergeDeepIn : Symbol(Map.mergeDeepIn, Decl(immutable.d.ts, 93, 70)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 94, 16)) +>mergeDeepIn : Symbol(Map.mergeDeepIn, Decl(immutable.ts, 93, 70)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 94, 16)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->collections : Symbol(collections, Decl(immutable.d.ts, 94, 39)) +>collections : Symbol(collections, Decl(immutable.ts, 94, 39)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) // Transient changes withMutations(mutator: (mutable: this) => any): this; ->withMutations : Symbol(Map.withMutations, Decl(immutable.d.ts, 94, 74)) ->mutator : Symbol(mutator, Decl(immutable.d.ts, 96, 18)) ->mutable : Symbol(mutable, Decl(immutable.d.ts, 96, 28)) +>withMutations : Symbol(Map.withMutations, Decl(immutable.ts, 94, 74)) +>mutator : Symbol(mutator, Decl(immutable.ts, 96, 18)) +>mutable : Symbol(mutable, Decl(immutable.ts, 96, 28)) asMutable(): this; ->asMutable : Symbol(Map.asMutable, Decl(immutable.d.ts, 96, 57)) +>asMutable : Symbol(Map.asMutable, Decl(immutable.ts, 96, 57)) asImmutable(): this; ->asImmutable : Symbol(Map.asImmutable, Decl(immutable.d.ts, 97, 22)) +>asImmutable : Symbol(Map.asImmutable, Decl(immutable.ts, 97, 22)) // Sequence algorithms concat(...collections: Array>): Map; ->concat : Symbol(Map.concat, Decl(immutable.d.ts, 98, 24), Decl(immutable.d.ts, 100, 83)) ->KC : Symbol(KC, Decl(immutable.d.ts, 100, 11)) ->VC : Symbol(VC, Decl(immutable.d.ts, 100, 14)) ->collections : Symbol(collections, Decl(immutable.d.ts, 100, 19)) +>concat : Symbol(Map.concat, Decl(immutable.ts, 98, 24), Decl(immutable.ts, 100, 83)) +>KC : Symbol(KC, Decl(immutable.ts, 100, 11)) +>VC : Symbol(VC, Decl(immutable.ts, 100, 14)) +>collections : Symbol(collections, Decl(immutable.ts, 100, 19)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->KC : Symbol(KC, Decl(immutable.d.ts, 100, 11)) ->VC : Symbol(VC, Decl(immutable.d.ts, 100, 14)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->KC : Symbol(KC, Decl(immutable.d.ts, 100, 11)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->VC : Symbol(VC, Decl(immutable.d.ts, 100, 14)) +>KC : Symbol(KC, Decl(immutable.ts, 100, 11)) +>VC : Symbol(VC, Decl(immutable.ts, 100, 14)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>KC : Symbol(KC, Decl(immutable.ts, 100, 11)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>VC : Symbol(VC, Decl(immutable.ts, 100, 14)) concat(...collections: Array<{[key: string]: C}>): Map; ->concat : Symbol(Map.concat, Decl(immutable.d.ts, 98, 24), Decl(immutable.d.ts, 100, 83)) ->C : Symbol(C, Decl(immutable.d.ts, 101, 11)) ->collections : Symbol(collections, Decl(immutable.d.ts, 101, 14)) +>concat : Symbol(Map.concat, Decl(immutable.ts, 98, 24), Decl(immutable.ts, 100, 83)) +>C : Symbol(C, Decl(immutable.ts, 101, 11)) +>collections : Symbol(collections, Decl(immutable.ts, 101, 14)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->key : Symbol(key, Decl(immutable.d.ts, 101, 38)) ->C : Symbol(C, Decl(immutable.d.ts, 101, 11)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->C : Symbol(C, Decl(immutable.d.ts, 101, 11)) +>key : Symbol(key, Decl(immutable.ts, 101, 38)) +>C : Symbol(C, Decl(immutable.ts, 101, 11)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>C : Symbol(C, Decl(immutable.ts, 101, 11)) map(mapper: (value: V, key: K, iter: this) => M, context?: any): Map; ->map : Symbol(Map.map, Decl(immutable.d.ts, 101, 81)) ->M : Symbol(M, Decl(immutable.d.ts, 102, 8)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 102, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 102, 20)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 102, 29)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->iter : Symbol(iter, Decl(immutable.d.ts, 102, 37)) ->M : Symbol(M, Decl(immutable.d.ts, 102, 8)) ->context : Symbol(context, Decl(immutable.d.ts, 102, 55)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->M : Symbol(M, Decl(immutable.d.ts, 102, 8)) +>map : Symbol(Map.map, Decl(immutable.ts, 101, 81)) +>M : Symbol(M, Decl(immutable.ts, 102, 8)) +>mapper : Symbol(mapper, Decl(immutable.ts, 102, 11)) +>value : Symbol(value, Decl(immutable.ts, 102, 20)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 102, 29)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>iter : Symbol(iter, Decl(immutable.ts, 102, 37)) +>M : Symbol(M, Decl(immutable.ts, 102, 8)) +>context : Symbol(context, Decl(immutable.ts, 102, 55)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>M : Symbol(M, Decl(immutable.ts, 102, 8)) mapKeys(mapper: (key: K, value: V, iter: this) => M, context?: any): Map; ->mapKeys : Symbol(Map.mapKeys, Decl(immutable.d.ts, 102, 82)) ->M : Symbol(M, Decl(immutable.d.ts, 103, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 103, 15)) ->key : Symbol(key, Decl(immutable.d.ts, 103, 24)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->value : Symbol(value, Decl(immutable.d.ts, 103, 31)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->iter : Symbol(iter, Decl(immutable.d.ts, 103, 41)) ->M : Symbol(M, Decl(immutable.d.ts, 103, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 103, 59)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->M : Symbol(M, Decl(immutable.d.ts, 103, 12)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) +>mapKeys : Symbol(Map.mapKeys, Decl(immutable.ts, 102, 82)) +>M : Symbol(M, Decl(immutable.ts, 103, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 103, 15)) +>key : Symbol(key, Decl(immutable.ts, 103, 24)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>value : Symbol(value, Decl(immutable.ts, 103, 31)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>iter : Symbol(iter, Decl(immutable.ts, 103, 41)) +>M : Symbol(M, Decl(immutable.ts, 103, 12)) +>context : Symbol(context, Decl(immutable.ts, 103, 59)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>M : Symbol(M, Decl(immutable.ts, 103, 12)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) mapEntries(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], context?: any): Map; ->mapEntries : Symbol(Map.mapEntries, Decl(immutable.d.ts, 103, 86)) ->KM : Symbol(KM, Decl(immutable.d.ts, 104, 15)) ->VM : Symbol(VM, Decl(immutable.d.ts, 104, 18)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 104, 23)) ->entry : Symbol(entry, Decl(immutable.d.ts, 104, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->index : Symbol(index, Decl(immutable.d.ts, 104, 46)) ->iter : Symbol(iter, Decl(immutable.d.ts, 104, 61)) ->KM : Symbol(KM, Decl(immutable.d.ts, 104, 15)) ->VM : Symbol(VM, Decl(immutable.d.ts, 104, 18)) ->context : Symbol(context, Decl(immutable.d.ts, 104, 86)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->KM : Symbol(KM, Decl(immutable.d.ts, 104, 15)) ->VM : Symbol(VM, Decl(immutable.d.ts, 104, 18)) +>mapEntries : Symbol(Map.mapEntries, Decl(immutable.ts, 103, 86)) +>KM : Symbol(KM, Decl(immutable.ts, 104, 15)) +>VM : Symbol(VM, Decl(immutable.ts, 104, 18)) +>mapper : Symbol(mapper, Decl(immutable.ts, 104, 23)) +>entry : Symbol(entry, Decl(immutable.ts, 104, 32)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>index : Symbol(index, Decl(immutable.ts, 104, 46)) +>iter : Symbol(iter, Decl(immutable.ts, 104, 61)) +>KM : Symbol(KM, Decl(immutable.ts, 104, 15)) +>VM : Symbol(VM, Decl(immutable.ts, 104, 18)) +>context : Symbol(context, Decl(immutable.ts, 104, 86)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>KM : Symbol(KM, Decl(immutable.ts, 104, 15)) +>VM : Symbol(VM, Decl(immutable.ts, 104, 18)) flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Map; ->flatMap : Symbol(Map.flatMap, Decl(immutable.d.ts, 104, 115)) ->M : Symbol(M, Decl(immutable.d.ts, 105, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 105, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 105, 24)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 105, 33)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->iter : Symbol(iter, Decl(immutable.d.ts, 105, 41)) +>flatMap : Symbol(Map.flatMap, Decl(immutable.ts, 104, 115)) +>M : Symbol(M, Decl(immutable.ts, 105, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 105, 15)) +>value : Symbol(value, Decl(immutable.ts, 105, 24)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 105, 33)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>iter : Symbol(iter, Decl(immutable.ts, 105, 41)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 105, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 105, 69)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) +>M : Symbol(M, Decl(immutable.ts, 105, 12)) +>context : Symbol(context, Decl(immutable.ts, 105, 69)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Map; ->filter : Symbol(Map.filter, Decl(immutable.d.ts, 105, 100), Decl(immutable.d.ts, 106, 107)) ->F : Symbol(F, Decl(immutable.d.ts, 106, 11)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 106, 24)) ->value : Symbol(value, Decl(immutable.d.ts, 106, 36)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 106, 45)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->iter : Symbol(iter, Decl(immutable.d.ts, 106, 53)) ->value : Symbol(value, Decl(immutable.d.ts, 106, 36)) ->F : Symbol(F, Decl(immutable.d.ts, 106, 11)) ->context : Symbol(context, Decl(immutable.d.ts, 106, 80)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->F : Symbol(F, Decl(immutable.d.ts, 106, 11)) +>filter : Symbol(Map.filter, Decl(immutable.ts, 105, 100), Decl(immutable.ts, 106, 107)) +>F : Symbol(F, Decl(immutable.ts, 106, 11)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>predicate : Symbol(predicate, Decl(immutable.ts, 106, 24)) +>value : Symbol(value, Decl(immutable.ts, 106, 36)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 106, 45)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>iter : Symbol(iter, Decl(immutable.ts, 106, 53)) +>value : Symbol(value, Decl(immutable.ts, 106, 36)) +>F : Symbol(F, Decl(immutable.ts, 106, 11)) +>context : Symbol(context, Decl(immutable.ts, 106, 80)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>F : Symbol(F, Decl(immutable.ts, 106, 11)) filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; ->filter : Symbol(Map.filter, Decl(immutable.d.ts, 105, 100), Decl(immutable.d.ts, 106, 107)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 107, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 107, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 72, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 107, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 72, 23)) ->iter : Symbol(iter, Decl(immutable.d.ts, 107, 40)) ->context : Symbol(context, Decl(immutable.d.ts, 107, 60)) +>filter : Symbol(Map.filter, Decl(immutable.ts, 105, 100), Decl(immutable.ts, 106, 107)) +>predicate : Symbol(predicate, Decl(immutable.ts, 107, 11)) +>value : Symbol(value, Decl(immutable.ts, 107, 23)) +>V : Symbol(V, Decl(immutable.ts, 72, 25)) +>key : Symbol(key, Decl(immutable.ts, 107, 32)) +>K : Symbol(K, Decl(immutable.ts, 72, 23)) +>iter : Symbol(iter, Decl(immutable.ts, 107, 40)) +>context : Symbol(context, Decl(immutable.ts, 107, 60)) } export module OrderedMap { ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) function isOrderedMap(maybeOrderedMap: any): maybeOrderedMap is OrderedMap; ->isOrderedMap : Symbol(isOrderedMap, Decl(immutable.d.ts, 109, 28)) ->maybeOrderedMap : Symbol(maybeOrderedMap, Decl(immutable.d.ts, 110, 26)) ->maybeOrderedMap : Symbol(maybeOrderedMap, Decl(immutable.d.ts, 110, 26)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) +>isOrderedMap : Symbol(isOrderedMap, Decl(immutable.ts, 109, 28)) +>maybeOrderedMap : Symbol(maybeOrderedMap, Decl(immutable.ts, 110, 26)) +>maybeOrderedMap : Symbol(maybeOrderedMap, Decl(immutable.ts, 110, 26)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) } export function OrderedMap(collection: Iterable<[K, V]>): OrderedMap; ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 112, 29)) ->V : Symbol(V, Decl(immutable.d.ts, 112, 31)) ->collection : Symbol(collection, Decl(immutable.d.ts, 112, 35)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 112, 29)) +>V : Symbol(V, Decl(immutable.ts, 112, 31)) +>collection : Symbol(collection, Decl(immutable.ts, 112, 35)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->K : Symbol(K, Decl(immutable.d.ts, 112, 29)) ->V : Symbol(V, Decl(immutable.d.ts, 112, 31)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 112, 29)) ->V : Symbol(V, Decl(immutable.d.ts, 112, 31)) +>K : Symbol(K, Decl(immutable.ts, 112, 29)) +>V : Symbol(V, Decl(immutable.ts, 112, 31)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 112, 29)) +>V : Symbol(V, Decl(immutable.ts, 112, 31)) export function OrderedMap(collection: Iterable>): OrderedMap; ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->T : Symbol(T, Decl(immutable.d.ts, 113, 29)) ->collection : Symbol(collection, Decl(immutable.d.ts, 113, 32)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>T : Symbol(T, Decl(immutable.ts, 113, 29)) +>collection : Symbol(collection, Decl(immutable.ts, 113, 32)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 113, 29)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->T : Symbol(T, Decl(immutable.d.ts, 113, 29)) ->T : Symbol(T, Decl(immutable.d.ts, 113, 29)) +>T : Symbol(T, Decl(immutable.ts, 113, 29)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>T : Symbol(T, Decl(immutable.ts, 113, 29)) +>T : Symbol(T, Decl(immutable.ts, 113, 29)) export function OrderedMap(obj: {[key: string]: V}): OrderedMap; ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->V : Symbol(V, Decl(immutable.d.ts, 114, 29)) ->obj : Symbol(obj, Decl(immutable.d.ts, 114, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 114, 39)) ->V : Symbol(V, Decl(immutable.d.ts, 114, 29)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->V : Symbol(V, Decl(immutable.d.ts, 114, 29)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>V : Symbol(V, Decl(immutable.ts, 114, 29)) +>obj : Symbol(obj, Decl(immutable.ts, 114, 32)) +>key : Symbol(key, Decl(immutable.ts, 114, 39)) +>V : Symbol(V, Decl(immutable.ts, 114, 29)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>V : Symbol(V, Decl(immutable.ts, 114, 29)) export function OrderedMap(): OrderedMap; ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 115, 29)) ->V : Symbol(V, Decl(immutable.d.ts, 115, 31)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 115, 29)) ->V : Symbol(V, Decl(immutable.d.ts, 115, 31)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 115, 29)) +>V : Symbol(V, Decl(immutable.ts, 115, 31)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 115, 29)) +>V : Symbol(V, Decl(immutable.ts, 115, 31)) export function OrderedMap(): OrderedMap; ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) export interface OrderedMap extends Map { ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) // Sequence algorithms concat(...collections: Array>): OrderedMap; ->concat : Symbol(OrderedMap.concat, Decl(immutable.d.ts, 117, 55), Decl(immutable.d.ts, 119, 90)) ->KC : Symbol(KC, Decl(immutable.d.ts, 119, 11)) ->VC : Symbol(VC, Decl(immutable.d.ts, 119, 14)) ->collections : Symbol(collections, Decl(immutable.d.ts, 119, 19)) +>concat : Symbol(OrderedMap.concat, Decl(immutable.ts, 117, 55), Decl(immutable.ts, 119, 90)) +>KC : Symbol(KC, Decl(immutable.ts, 119, 11)) +>VC : Symbol(VC, Decl(immutable.ts, 119, 14)) +>collections : Symbol(collections, Decl(immutable.ts, 119, 19)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->KC : Symbol(KC, Decl(immutable.d.ts, 119, 11)) ->VC : Symbol(VC, Decl(immutable.d.ts, 119, 14)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->KC : Symbol(KC, Decl(immutable.d.ts, 119, 11)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->VC : Symbol(VC, Decl(immutable.d.ts, 119, 14)) +>KC : Symbol(KC, Decl(immutable.ts, 119, 11)) +>VC : Symbol(VC, Decl(immutable.ts, 119, 14)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>KC : Symbol(KC, Decl(immutable.ts, 119, 11)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>VC : Symbol(VC, Decl(immutable.ts, 119, 14)) concat(...collections: Array<{[key: string]: C}>): OrderedMap; ->concat : Symbol(OrderedMap.concat, Decl(immutable.d.ts, 117, 55), Decl(immutable.d.ts, 119, 90)) ->C : Symbol(C, Decl(immutable.d.ts, 120, 11)) ->collections : Symbol(collections, Decl(immutable.d.ts, 120, 14)) +>concat : Symbol(OrderedMap.concat, Decl(immutable.ts, 117, 55), Decl(immutable.ts, 119, 90)) +>C : Symbol(C, Decl(immutable.ts, 120, 11)) +>collections : Symbol(collections, Decl(immutable.ts, 120, 14)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->key : Symbol(key, Decl(immutable.d.ts, 120, 38)) ->C : Symbol(C, Decl(immutable.d.ts, 120, 11)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->C : Symbol(C, Decl(immutable.d.ts, 120, 11)) +>key : Symbol(key, Decl(immutable.ts, 120, 38)) +>C : Symbol(C, Decl(immutable.ts, 120, 11)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>C : Symbol(C, Decl(immutable.ts, 120, 11)) map(mapper: (value: V, key: K, iter: this) => M, context?: any): OrderedMap; ->map : Symbol(OrderedMap.map, Decl(immutable.d.ts, 120, 88)) ->M : Symbol(M, Decl(immutable.d.ts, 121, 8)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 121, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 121, 20)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 121, 29)) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 121, 37)) ->M : Symbol(M, Decl(immutable.d.ts, 121, 8)) ->context : Symbol(context, Decl(immutable.d.ts, 121, 55)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->M : Symbol(M, Decl(immutable.d.ts, 121, 8)) +>map : Symbol(OrderedMap.map, Decl(immutable.ts, 120, 88)) +>M : Symbol(M, Decl(immutable.ts, 121, 8)) +>mapper : Symbol(mapper, Decl(immutable.ts, 121, 11)) +>value : Symbol(value, Decl(immutable.ts, 121, 20)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>key : Symbol(key, Decl(immutable.ts, 121, 29)) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 121, 37)) +>M : Symbol(M, Decl(immutable.ts, 121, 8)) +>context : Symbol(context, Decl(immutable.ts, 121, 55)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>M : Symbol(M, Decl(immutable.ts, 121, 8)) mapKeys(mapper: (key: K, value: V, iter: this) => M, context?: any): OrderedMap; ->mapKeys : Symbol(OrderedMap.mapKeys, Decl(immutable.d.ts, 121, 89)) ->M : Symbol(M, Decl(immutable.d.ts, 122, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 122, 15)) ->key : Symbol(key, Decl(immutable.d.ts, 122, 24)) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->value : Symbol(value, Decl(immutable.d.ts, 122, 31)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->iter : Symbol(iter, Decl(immutable.d.ts, 122, 41)) ->M : Symbol(M, Decl(immutable.d.ts, 122, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 122, 59)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->M : Symbol(M, Decl(immutable.d.ts, 122, 12)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) +>mapKeys : Symbol(OrderedMap.mapKeys, Decl(immutable.ts, 121, 89)) +>M : Symbol(M, Decl(immutable.ts, 122, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 122, 15)) +>key : Symbol(key, Decl(immutable.ts, 122, 24)) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>value : Symbol(value, Decl(immutable.ts, 122, 31)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>iter : Symbol(iter, Decl(immutable.ts, 122, 41)) +>M : Symbol(M, Decl(immutable.ts, 122, 12)) +>context : Symbol(context, Decl(immutable.ts, 122, 59)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>M : Symbol(M, Decl(immutable.ts, 122, 12)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) mapEntries(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], context?: any): OrderedMap; ->mapEntries : Symbol(OrderedMap.mapEntries, Decl(immutable.d.ts, 122, 93)) ->KM : Symbol(KM, Decl(immutable.d.ts, 123, 15)) ->VM : Symbol(VM, Decl(immutable.d.ts, 123, 18)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 123, 23)) ->entry : Symbol(entry, Decl(immutable.d.ts, 123, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->index : Symbol(index, Decl(immutable.d.ts, 123, 46)) ->iter : Symbol(iter, Decl(immutable.d.ts, 123, 61)) ->KM : Symbol(KM, Decl(immutable.d.ts, 123, 15)) ->VM : Symbol(VM, Decl(immutable.d.ts, 123, 18)) ->context : Symbol(context, Decl(immutable.d.ts, 123, 86)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->KM : Symbol(KM, Decl(immutable.d.ts, 123, 15)) ->VM : Symbol(VM, Decl(immutable.d.ts, 123, 18)) +>mapEntries : Symbol(OrderedMap.mapEntries, Decl(immutable.ts, 122, 93)) +>KM : Symbol(KM, Decl(immutable.ts, 123, 15)) +>VM : Symbol(VM, Decl(immutable.ts, 123, 18)) +>mapper : Symbol(mapper, Decl(immutable.ts, 123, 23)) +>entry : Symbol(entry, Decl(immutable.ts, 123, 32)) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>index : Symbol(index, Decl(immutable.ts, 123, 46)) +>iter : Symbol(iter, Decl(immutable.ts, 123, 61)) +>KM : Symbol(KM, Decl(immutable.ts, 123, 15)) +>VM : Symbol(VM, Decl(immutable.ts, 123, 18)) +>context : Symbol(context, Decl(immutable.ts, 123, 86)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>KM : Symbol(KM, Decl(immutable.ts, 123, 15)) +>VM : Symbol(VM, Decl(immutable.ts, 123, 18)) flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): OrderedMap; ->flatMap : Symbol(OrderedMap.flatMap, Decl(immutable.d.ts, 123, 122)) ->M : Symbol(M, Decl(immutable.d.ts, 124, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 124, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 124, 24)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 124, 33)) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 124, 41)) +>flatMap : Symbol(OrderedMap.flatMap, Decl(immutable.ts, 123, 122)) +>M : Symbol(M, Decl(immutable.ts, 124, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 124, 15)) +>value : Symbol(value, Decl(immutable.ts, 124, 24)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>key : Symbol(key, Decl(immutable.ts, 124, 33)) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 124, 41)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 124, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 124, 69)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) +>M : Symbol(M, Decl(immutable.ts, 124, 12)) +>context : Symbol(context, Decl(immutable.ts, 124, 69)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): OrderedMap; ->filter : Symbol(OrderedMap.filter, Decl(immutable.d.ts, 124, 107), Decl(immutable.d.ts, 125, 114)) ->F : Symbol(F, Decl(immutable.d.ts, 125, 11)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 125, 24)) ->value : Symbol(value, Decl(immutable.d.ts, 125, 36)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 125, 45)) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 125, 53)) ->value : Symbol(value, Decl(immutable.d.ts, 125, 36)) ->F : Symbol(F, Decl(immutable.d.ts, 125, 11)) ->context : Symbol(context, Decl(immutable.d.ts, 125, 80)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->F : Symbol(F, Decl(immutable.d.ts, 125, 11)) +>filter : Symbol(OrderedMap.filter, Decl(immutable.ts, 124, 107), Decl(immutable.ts, 125, 114)) +>F : Symbol(F, Decl(immutable.ts, 125, 11)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>predicate : Symbol(predicate, Decl(immutable.ts, 125, 24)) +>value : Symbol(value, Decl(immutable.ts, 125, 36)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>key : Symbol(key, Decl(immutable.ts, 125, 45)) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 125, 53)) +>value : Symbol(value, Decl(immutable.ts, 125, 36)) +>F : Symbol(F, Decl(immutable.ts, 125, 11)) +>context : Symbol(context, Decl(immutable.ts, 125, 80)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>F : Symbol(F, Decl(immutable.ts, 125, 11)) filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; ->filter : Symbol(OrderedMap.filter, Decl(immutable.d.ts, 124, 107), Decl(immutable.d.ts, 125, 114)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 126, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 126, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 117, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 126, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 117, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 126, 40)) ->context : Symbol(context, Decl(immutable.d.ts, 126, 60)) +>filter : Symbol(OrderedMap.filter, Decl(immutable.ts, 124, 107), Decl(immutable.ts, 125, 114)) +>predicate : Symbol(predicate, Decl(immutable.ts, 126, 11)) +>value : Symbol(value, Decl(immutable.ts, 126, 23)) +>V : Symbol(V, Decl(immutable.ts, 117, 32)) +>key : Symbol(key, Decl(immutable.ts, 126, 32)) +>K : Symbol(K, Decl(immutable.ts, 117, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 126, 40)) +>context : Symbol(context, Decl(immutable.ts, 126, 60)) } export module Set { ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) function isSet(maybeSet: any): maybeSet is Set; ->isSet : Symbol(isSet, Decl(immutable.d.ts, 128, 21)) ->maybeSet : Symbol(maybeSet, Decl(immutable.d.ts, 129, 19)) ->maybeSet : Symbol(maybeSet, Decl(immutable.d.ts, 129, 19)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) +>isSet : Symbol(isSet, Decl(immutable.ts, 128, 21)) +>maybeSet : Symbol(maybeSet, Decl(immutable.ts, 129, 19)) +>maybeSet : Symbol(maybeSet, Decl(immutable.ts, 129, 19)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) function of(...values: Array): Set; ->of : Symbol(of, Decl(immutable.d.ts, 129, 56)) ->T : Symbol(T, Decl(immutable.d.ts, 130, 16)) ->values : Symbol(values, Decl(immutable.d.ts, 130, 19)) +>of : Symbol(of, Decl(immutable.ts, 129, 56)) +>T : Symbol(T, Decl(immutable.ts, 130, 16)) +>values : Symbol(values, Decl(immutable.ts, 130, 19)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 130, 16)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 130, 16)) +>T : Symbol(T, Decl(immutable.ts, 130, 16)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 130, 16)) function fromKeys(iter: Collection): Set; ->fromKeys : Symbol(fromKeys, Decl(immutable.d.ts, 130, 48), Decl(immutable.d.ts, 131, 59)) ->T : Symbol(T, Decl(immutable.d.ts, 131, 22)) ->iter : Symbol(iter, Decl(immutable.d.ts, 131, 25)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 131, 22)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 131, 22)) +>fromKeys : Symbol(fromKeys, Decl(immutable.ts, 130, 48), Decl(immutable.ts, 131, 59)) +>T : Symbol(T, Decl(immutable.ts, 131, 22)) +>iter : Symbol(iter, Decl(immutable.ts, 131, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 131, 22)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 131, 22)) function fromKeys(obj: {[key: string]: any}): Set; ->fromKeys : Symbol(fromKeys, Decl(immutable.d.ts, 130, 48), Decl(immutable.d.ts, 131, 59)) ->obj : Symbol(obj, Decl(immutable.d.ts, 132, 22)) ->key : Symbol(key, Decl(immutable.d.ts, 132, 29)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) +>fromKeys : Symbol(fromKeys, Decl(immutable.ts, 130, 48), Decl(immutable.ts, 131, 59)) +>obj : Symbol(obj, Decl(immutable.ts, 132, 22)) +>key : Symbol(key, Decl(immutable.ts, 132, 29)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) function intersect(sets: Iterable>): Set; ->intersect : Symbol(intersect, Decl(immutable.d.ts, 132, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 133, 23)) ->sets : Symbol(sets, Decl(immutable.d.ts, 133, 26)) +>intersect : Symbol(intersect, Decl(immutable.ts, 132, 62)) +>T : Symbol(T, Decl(immutable.ts, 133, 23)) +>sets : Symbol(sets, Decl(immutable.ts, 133, 26)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 133, 23)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 133, 23)) +>T : Symbol(T, Decl(immutable.ts, 133, 23)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 133, 23)) function union(sets: Iterable>): Set; ->union : Symbol(union, Decl(immutable.d.ts, 133, 63)) ->T : Symbol(T, Decl(immutable.d.ts, 134, 19)) ->sets : Symbol(sets, Decl(immutable.d.ts, 134, 22)) +>union : Symbol(union, Decl(immutable.ts, 133, 63)) +>T : Symbol(T, Decl(immutable.ts, 134, 19)) +>sets : Symbol(sets, Decl(immutable.ts, 134, 22)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 134, 19)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 134, 19)) +>T : Symbol(T, Decl(immutable.ts, 134, 19)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 134, 19)) } export function Set(): Set; ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) export function Set(): Set; ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 137, 22)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 137, 22)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 137, 22)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 137, 22)) export function Set(collection: Iterable): Set; ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 138, 22)) ->collection : Symbol(collection, Decl(immutable.d.ts, 138, 25)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 138, 22)) +>collection : Symbol(collection, Decl(immutable.ts, 138, 25)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 138, 22)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 138, 22)) +>T : Symbol(T, Decl(immutable.ts, 138, 22)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 138, 22)) export interface Set extends Collection.Set { ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) ->Collection.Set : Symbol(Collection.Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Set : Symbol(Collection.Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) +>Collection.Set : Symbol(Collection.Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Set : Symbol(Collection.Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) // Persistent changes add(value: T): this; ->add : Symbol(Set.add, Decl(immutable.d.ts, 139, 53)) ->value : Symbol(value, Decl(immutable.d.ts, 141, 8)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>add : Symbol(Set.add, Decl(immutable.ts, 139, 53)) +>value : Symbol(value, Decl(immutable.ts, 141, 8)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) delete(value: T): this; ->delete : Symbol(Set.delete, Decl(immutable.d.ts, 141, 24)) ->value : Symbol(value, Decl(immutable.d.ts, 142, 11)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>delete : Symbol(Set.delete, Decl(immutable.ts, 141, 24)) +>value : Symbol(value, Decl(immutable.ts, 142, 11)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) remove(value: T): this; ->remove : Symbol(Set.remove, Decl(immutable.d.ts, 142, 27)) ->value : Symbol(value, Decl(immutable.d.ts, 143, 11)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>remove : Symbol(Set.remove, Decl(immutable.ts, 142, 27)) +>value : Symbol(value, Decl(immutable.ts, 143, 11)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) clear(): this; ->clear : Symbol(Set.clear, Decl(immutable.d.ts, 143, 27)) +>clear : Symbol(Set.clear, Decl(immutable.ts, 143, 27)) union(...collections: Array | Array>): this; ->union : Symbol(Set.union, Decl(immutable.d.ts, 144, 18)) ->collections : Symbol(collections, Decl(immutable.d.ts, 145, 10)) +>union : Symbol(Set.union, Decl(immutable.ts, 144, 18)) +>collections : Symbol(collections, Decl(immutable.ts, 145, 10)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) merge(...collections: Array | Array>): this; ->merge : Symbol(Set.merge, Decl(immutable.d.ts, 145, 70)) ->collections : Symbol(collections, Decl(immutable.d.ts, 146, 10)) +>merge : Symbol(Set.merge, Decl(immutable.ts, 145, 70)) +>collections : Symbol(collections, Decl(immutable.ts, 146, 10)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) intersect(...collections: Array | Array>): this; ->intersect : Symbol(Set.intersect, Decl(immutable.d.ts, 146, 70)) ->collections : Symbol(collections, Decl(immutable.d.ts, 147, 14)) +>intersect : Symbol(Set.intersect, Decl(immutable.ts, 146, 70)) +>collections : Symbol(collections, Decl(immutable.ts, 147, 14)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) subtract(...collections: Array | Array>): this; ->subtract : Symbol(Set.subtract, Decl(immutable.d.ts, 147, 74)) ->collections : Symbol(collections, Decl(immutable.d.ts, 148, 13)) +>subtract : Symbol(Set.subtract, Decl(immutable.ts, 147, 74)) +>collections : Symbol(collections, Decl(immutable.ts, 148, 13)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) // Transient changes withMutations(mutator: (mutable: this) => any): this; ->withMutations : Symbol(Set.withMutations, Decl(immutable.d.ts, 148, 73)) ->mutator : Symbol(mutator, Decl(immutable.d.ts, 150, 18)) ->mutable : Symbol(mutable, Decl(immutable.d.ts, 150, 28)) +>withMutations : Symbol(Set.withMutations, Decl(immutable.ts, 148, 73)) +>mutator : Symbol(mutator, Decl(immutable.ts, 150, 18)) +>mutable : Symbol(mutable, Decl(immutable.ts, 150, 28)) asMutable(): this; ->asMutable : Symbol(Set.asMutable, Decl(immutable.d.ts, 150, 57)) +>asMutable : Symbol(Set.asMutable, Decl(immutable.ts, 150, 57)) asImmutable(): this; ->asImmutable : Symbol(Set.asImmutable, Decl(immutable.d.ts, 151, 22)) +>asImmutable : Symbol(Set.asImmutable, Decl(immutable.ts, 151, 22)) // Sequence algorithms concat(...valuesOrCollections: Array | C>): Set; ->concat : Symbol(Set.concat, Decl(immutable.d.ts, 152, 24)) ->C : Symbol(C, Decl(immutable.d.ts, 154, 11)) ->valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.d.ts, 154, 14)) +>concat : Symbol(Set.concat, Decl(immutable.ts, 152, 24)) +>C : Symbol(C, Decl(immutable.ts, 154, 11)) +>valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.ts, 154, 14)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->C : Symbol(C, Decl(immutable.d.ts, 154, 11)) ->C : Symbol(C, Decl(immutable.d.ts, 154, 11)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) ->C : Symbol(C, Decl(immutable.d.ts, 154, 11)) +>C : Symbol(C, Decl(immutable.ts, 154, 11)) +>C : Symbol(C, Decl(immutable.ts, 154, 11)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) +>C : Symbol(C, Decl(immutable.ts, 154, 11)) map(mapper: (value: T, key: never, iter: this) => M, context?: any): Set; ->map : Symbol(Set.map, Decl(immutable.d.ts, 154, 74)) ->M : Symbol(M, Decl(immutable.d.ts, 155, 8)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 155, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 155, 20)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) ->key : Symbol(key, Decl(immutable.d.ts, 155, 29)) ->iter : Symbol(iter, Decl(immutable.d.ts, 155, 41)) ->M : Symbol(M, Decl(immutable.d.ts, 155, 8)) ->context : Symbol(context, Decl(immutable.d.ts, 155, 59)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->M : Symbol(M, Decl(immutable.d.ts, 155, 8)) +>map : Symbol(Set.map, Decl(immutable.ts, 154, 74)) +>M : Symbol(M, Decl(immutable.ts, 155, 8)) +>mapper : Symbol(mapper, Decl(immutable.ts, 155, 11)) +>value : Symbol(value, Decl(immutable.ts, 155, 20)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) +>key : Symbol(key, Decl(immutable.ts, 155, 29)) +>iter : Symbol(iter, Decl(immutable.ts, 155, 41)) +>M : Symbol(M, Decl(immutable.ts, 155, 8)) +>context : Symbol(context, Decl(immutable.ts, 155, 59)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>M : Symbol(M, Decl(immutable.ts, 155, 8)) flatMap(mapper: (value: T, key: never, iter: this) => Iterable, context?: any): Set; ->flatMap : Symbol(Set.flatMap, Decl(immutable.d.ts, 155, 83)) ->M : Symbol(M, Decl(immutable.d.ts, 156, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 156, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 156, 24)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) ->key : Symbol(key, Decl(immutable.d.ts, 156, 33)) ->iter : Symbol(iter, Decl(immutable.d.ts, 156, 45)) +>flatMap : Symbol(Set.flatMap, Decl(immutable.ts, 155, 83)) +>M : Symbol(M, Decl(immutable.ts, 156, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 156, 15)) +>value : Symbol(value, Decl(immutable.ts, 156, 24)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) +>key : Symbol(key, Decl(immutable.ts, 156, 33)) +>iter : Symbol(iter, Decl(immutable.ts, 156, 45)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 156, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 156, 73)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->M : Symbol(M, Decl(immutable.d.ts, 156, 12)) +>M : Symbol(M, Decl(immutable.ts, 156, 12)) +>context : Symbol(context, Decl(immutable.ts, 156, 73)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>M : Symbol(M, Decl(immutable.ts, 156, 12)) filter(predicate: (value: T, key: never, iter: this) => value is F, context?: any): Set; ->filter : Symbol(Set.filter, Decl(immutable.d.ts, 156, 97), Decl(immutable.d.ts, 157, 108)) ->F : Symbol(F, Decl(immutable.d.ts, 157, 11)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 157, 24)) ->value : Symbol(value, Decl(immutable.d.ts, 157, 36)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) ->key : Symbol(key, Decl(immutable.d.ts, 157, 45)) ->iter : Symbol(iter, Decl(immutable.d.ts, 157, 57)) ->value : Symbol(value, Decl(immutable.d.ts, 157, 36)) ->F : Symbol(F, Decl(immutable.d.ts, 157, 11)) ->context : Symbol(context, Decl(immutable.d.ts, 157, 84)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->F : Symbol(F, Decl(immutable.d.ts, 157, 11)) +>filter : Symbol(Set.filter, Decl(immutable.ts, 156, 97), Decl(immutable.ts, 157, 108)) +>F : Symbol(F, Decl(immutable.ts, 157, 11)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) +>predicate : Symbol(predicate, Decl(immutable.ts, 157, 24)) +>value : Symbol(value, Decl(immutable.ts, 157, 36)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) +>key : Symbol(key, Decl(immutable.ts, 157, 45)) +>iter : Symbol(iter, Decl(immutable.ts, 157, 57)) +>value : Symbol(value, Decl(immutable.ts, 157, 36)) +>F : Symbol(F, Decl(immutable.ts, 157, 11)) +>context : Symbol(context, Decl(immutable.ts, 157, 84)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>F : Symbol(F, Decl(immutable.ts, 157, 11)) filter(predicate: (value: T, key: never, iter: this) => any, context?: any): this; ->filter : Symbol(Set.filter, Decl(immutable.d.ts, 156, 97), Decl(immutable.d.ts, 157, 108)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 158, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 158, 23)) ->T : Symbol(T, Decl(immutable.d.ts, 139, 23)) ->key : Symbol(key, Decl(immutable.d.ts, 158, 32)) ->iter : Symbol(iter, Decl(immutable.d.ts, 158, 44)) ->context : Symbol(context, Decl(immutable.d.ts, 158, 64)) +>filter : Symbol(Set.filter, Decl(immutable.ts, 156, 97), Decl(immutable.ts, 157, 108)) +>predicate : Symbol(predicate, Decl(immutable.ts, 158, 11)) +>value : Symbol(value, Decl(immutable.ts, 158, 23)) +>T : Symbol(T, Decl(immutable.ts, 139, 23)) +>key : Symbol(key, Decl(immutable.ts, 158, 32)) +>iter : Symbol(iter, Decl(immutable.ts, 158, 44)) +>context : Symbol(context, Decl(immutable.ts, 158, 64)) } export module OrderedSet { ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) function isOrderedSet(maybeOrderedSet: any): boolean; ->isOrderedSet : Symbol(isOrderedSet, Decl(immutable.d.ts, 160, 28)) ->maybeOrderedSet : Symbol(maybeOrderedSet, Decl(immutable.d.ts, 161, 26)) +>isOrderedSet : Symbol(isOrderedSet, Decl(immutable.ts, 160, 28)) +>maybeOrderedSet : Symbol(maybeOrderedSet, Decl(immutable.ts, 161, 26)) function of(...values: Array): OrderedSet; ->of : Symbol(of, Decl(immutable.d.ts, 161, 57)) ->T : Symbol(T, Decl(immutable.d.ts, 162, 16)) ->values : Symbol(values, Decl(immutable.d.ts, 162, 19)) +>of : Symbol(of, Decl(immutable.ts, 161, 57)) +>T : Symbol(T, Decl(immutable.ts, 162, 16)) +>values : Symbol(values, Decl(immutable.ts, 162, 19)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 162, 16)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 162, 16)) +>T : Symbol(T, Decl(immutable.ts, 162, 16)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>T : Symbol(T, Decl(immutable.ts, 162, 16)) function fromKeys(iter: Collection): OrderedSet; ->fromKeys : Symbol(fromKeys, Decl(immutable.d.ts, 162, 55), Decl(immutable.d.ts, 163, 66)) ->T : Symbol(T, Decl(immutable.d.ts, 163, 22)) ->iter : Symbol(iter, Decl(immutable.d.ts, 163, 25)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 163, 22)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 163, 22)) +>fromKeys : Symbol(fromKeys, Decl(immutable.ts, 162, 55), Decl(immutable.ts, 163, 66)) +>T : Symbol(T, Decl(immutable.ts, 163, 22)) +>iter : Symbol(iter, Decl(immutable.ts, 163, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 163, 22)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>T : Symbol(T, Decl(immutable.ts, 163, 22)) function fromKeys(obj: {[key: string]: any}): OrderedSet; ->fromKeys : Symbol(fromKeys, Decl(immutable.d.ts, 162, 55), Decl(immutable.d.ts, 163, 66)) ->obj : Symbol(obj, Decl(immutable.d.ts, 164, 22)) ->key : Symbol(key, Decl(immutable.d.ts, 164, 29)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) +>fromKeys : Symbol(fromKeys, Decl(immutable.ts, 162, 55), Decl(immutable.ts, 163, 66)) +>obj : Symbol(obj, Decl(immutable.ts, 164, 22)) +>key : Symbol(key, Decl(immutable.ts, 164, 29)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) } export function OrderedSet(): OrderedSet; ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) export function OrderedSet(): OrderedSet; ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 167, 29)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 167, 29)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>T : Symbol(T, Decl(immutable.ts, 167, 29)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>T : Symbol(T, Decl(immutable.ts, 167, 29)) export function OrderedSet(collection: Iterable): OrderedSet; ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 168, 29)) ->collection : Symbol(collection, Decl(immutable.d.ts, 168, 32)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>T : Symbol(T, Decl(immutable.ts, 168, 29)) +>collection : Symbol(collection, Decl(immutable.ts, 168, 32)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 168, 29)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 168, 29)) +>T : Symbol(T, Decl(immutable.ts, 168, 29)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>T : Symbol(T, Decl(immutable.ts, 168, 29)) export interface OrderedSet extends Set { ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) // Sequence algorithms concat(...valuesOrCollections: Array | C>): OrderedSet; ->concat : Symbol(OrderedSet.concat, Decl(immutable.d.ts, 169, 49)) ->C : Symbol(C, Decl(immutable.d.ts, 171, 11)) ->valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.d.ts, 171, 14)) +>concat : Symbol(OrderedSet.concat, Decl(immutable.ts, 169, 49)) +>C : Symbol(C, Decl(immutable.ts, 171, 11)) +>valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.ts, 171, 14)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->C : Symbol(C, Decl(immutable.d.ts, 171, 11)) ->C : Symbol(C, Decl(immutable.d.ts, 171, 11)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) ->C : Symbol(C, Decl(immutable.d.ts, 171, 11)) +>C : Symbol(C, Decl(immutable.ts, 171, 11)) +>C : Symbol(C, Decl(immutable.ts, 171, 11)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) +>C : Symbol(C, Decl(immutable.ts, 171, 11)) map(mapper: (value: T, key: never, iter: this) => M, context?: any): OrderedSet; ->map : Symbol(OrderedSet.map, Decl(immutable.d.ts, 171, 81)) ->M : Symbol(M, Decl(immutable.d.ts, 172, 8)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 172, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 172, 20)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) ->key : Symbol(key, Decl(immutable.d.ts, 172, 29)) ->iter : Symbol(iter, Decl(immutable.d.ts, 172, 41)) ->M : Symbol(M, Decl(immutable.d.ts, 172, 8)) ->context : Symbol(context, Decl(immutable.d.ts, 172, 59)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->M : Symbol(M, Decl(immutable.d.ts, 172, 8)) +>map : Symbol(OrderedSet.map, Decl(immutable.ts, 171, 81)) +>M : Symbol(M, Decl(immutable.ts, 172, 8)) +>mapper : Symbol(mapper, Decl(immutable.ts, 172, 11)) +>value : Symbol(value, Decl(immutable.ts, 172, 20)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) +>key : Symbol(key, Decl(immutable.ts, 172, 29)) +>iter : Symbol(iter, Decl(immutable.ts, 172, 41)) +>M : Symbol(M, Decl(immutable.ts, 172, 8)) +>context : Symbol(context, Decl(immutable.ts, 172, 59)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>M : Symbol(M, Decl(immutable.ts, 172, 8)) flatMap(mapper: (value: T, key: never, iter: this) => Iterable, context?: any): OrderedSet; ->flatMap : Symbol(OrderedSet.flatMap, Decl(immutable.d.ts, 172, 90)) ->M : Symbol(M, Decl(immutable.d.ts, 173, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 173, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 173, 24)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) ->key : Symbol(key, Decl(immutable.d.ts, 173, 33)) ->iter : Symbol(iter, Decl(immutable.d.ts, 173, 45)) +>flatMap : Symbol(OrderedSet.flatMap, Decl(immutable.ts, 172, 90)) +>M : Symbol(M, Decl(immutable.ts, 173, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 173, 15)) +>value : Symbol(value, Decl(immutable.ts, 173, 24)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) +>key : Symbol(key, Decl(immutable.ts, 173, 33)) +>iter : Symbol(iter, Decl(immutable.ts, 173, 45)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 173, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 173, 73)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->M : Symbol(M, Decl(immutable.d.ts, 173, 12)) +>M : Symbol(M, Decl(immutable.ts, 173, 12)) +>context : Symbol(context, Decl(immutable.ts, 173, 73)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>M : Symbol(M, Decl(immutable.ts, 173, 12)) filter(predicate: (value: T, key: never, iter: this) => value is F, context?: any): OrderedSet; ->filter : Symbol(OrderedSet.filter, Decl(immutable.d.ts, 173, 104), Decl(immutable.d.ts, 174, 115)) ->F : Symbol(F, Decl(immutable.d.ts, 174, 11)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 174, 24)) ->value : Symbol(value, Decl(immutable.d.ts, 174, 36)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) ->key : Symbol(key, Decl(immutable.d.ts, 174, 45)) ->iter : Symbol(iter, Decl(immutable.d.ts, 174, 57)) ->value : Symbol(value, Decl(immutable.d.ts, 174, 36)) ->F : Symbol(F, Decl(immutable.d.ts, 174, 11)) ->context : Symbol(context, Decl(immutable.d.ts, 174, 84)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->F : Symbol(F, Decl(immutable.d.ts, 174, 11)) +>filter : Symbol(OrderedSet.filter, Decl(immutable.ts, 173, 104), Decl(immutable.ts, 174, 115)) +>F : Symbol(F, Decl(immutable.ts, 174, 11)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) +>predicate : Symbol(predicate, Decl(immutable.ts, 174, 24)) +>value : Symbol(value, Decl(immutable.ts, 174, 36)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) +>key : Symbol(key, Decl(immutable.ts, 174, 45)) +>iter : Symbol(iter, Decl(immutable.ts, 174, 57)) +>value : Symbol(value, Decl(immutable.ts, 174, 36)) +>F : Symbol(F, Decl(immutable.ts, 174, 11)) +>context : Symbol(context, Decl(immutable.ts, 174, 84)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>F : Symbol(F, Decl(immutable.ts, 174, 11)) filter(predicate: (value: T, key: never, iter: this) => any, context?: any): this; ->filter : Symbol(OrderedSet.filter, Decl(immutable.d.ts, 173, 104), Decl(immutable.d.ts, 174, 115)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 175, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 175, 23)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) ->key : Symbol(key, Decl(immutable.d.ts, 175, 32)) ->iter : Symbol(iter, Decl(immutable.d.ts, 175, 44)) ->context : Symbol(context, Decl(immutable.d.ts, 175, 64)) +>filter : Symbol(OrderedSet.filter, Decl(immutable.ts, 173, 104), Decl(immutable.ts, 174, 115)) +>predicate : Symbol(predicate, Decl(immutable.ts, 175, 11)) +>value : Symbol(value, Decl(immutable.ts, 175, 23)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) +>key : Symbol(key, Decl(immutable.ts, 175, 32)) +>iter : Symbol(iter, Decl(immutable.ts, 175, 44)) +>context : Symbol(context, Decl(immutable.ts, 175, 64)) zip(...collections: Array>): OrderedSet; ->zip : Symbol(OrderedSet.zip, Decl(immutable.d.ts, 175, 86)) ->collections : Symbol(collections, Decl(immutable.d.ts, 176, 8)) +>zip : Symbol(OrderedSet.zip, Decl(immutable.ts, 175, 86)) +>collections : Symbol(collections, Decl(immutable.ts, 176, 8)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) zipWith(zipper: (value: T, otherValue: U) => Z, otherCollection: Collection): OrderedSet; ->zipWith : Symbol(OrderedSet.zipWith, Decl(immutable.d.ts, 176, 70), Decl(immutable.d.ts, 177, 110), Decl(immutable.d.ts, 178, 165)) ->U : Symbol(U, Decl(immutable.d.ts, 177, 12)) ->Z : Symbol(Z, Decl(immutable.d.ts, 177, 14)) ->zipper : Symbol(zipper, Decl(immutable.d.ts, 177, 18)) ->value : Symbol(value, Decl(immutable.d.ts, 177, 27)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) ->otherValue : Symbol(otherValue, Decl(immutable.d.ts, 177, 36)) ->U : Symbol(U, Decl(immutable.d.ts, 177, 12)) ->Z : Symbol(Z, Decl(immutable.d.ts, 177, 14)) ->otherCollection : Symbol(otherCollection, Decl(immutable.d.ts, 177, 57)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->U : Symbol(U, Decl(immutable.d.ts, 177, 12)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->Z : Symbol(Z, Decl(immutable.d.ts, 177, 14)) +>zipWith : Symbol(OrderedSet.zipWith, Decl(immutable.ts, 176, 70), Decl(immutable.ts, 177, 110), Decl(immutable.ts, 178, 165)) +>U : Symbol(U, Decl(immutable.ts, 177, 12)) +>Z : Symbol(Z, Decl(immutable.ts, 177, 14)) +>zipper : Symbol(zipper, Decl(immutable.ts, 177, 18)) +>value : Symbol(value, Decl(immutable.ts, 177, 27)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) +>otherValue : Symbol(otherValue, Decl(immutable.ts, 177, 36)) +>U : Symbol(U, Decl(immutable.ts, 177, 12)) +>Z : Symbol(Z, Decl(immutable.ts, 177, 14)) +>otherCollection : Symbol(otherCollection, Decl(immutable.ts, 177, 57)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>U : Symbol(U, Decl(immutable.ts, 177, 12)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>Z : Symbol(Z, Decl(immutable.ts, 177, 14)) zipWith(zipper: (value: T, otherValue: U, thirdValue: V) => Z, otherCollection: Collection, thirdCollection: Collection): OrderedSet; ->zipWith : Symbol(OrderedSet.zipWith, Decl(immutable.d.ts, 176, 70), Decl(immutable.d.ts, 177, 110), Decl(immutable.d.ts, 178, 165)) ->U : Symbol(U, Decl(immutable.d.ts, 178, 12)) ->V : Symbol(V, Decl(immutable.d.ts, 178, 14)) ->Z : Symbol(Z, Decl(immutable.d.ts, 178, 17)) ->zipper : Symbol(zipper, Decl(immutable.d.ts, 178, 21)) ->value : Symbol(value, Decl(immutable.d.ts, 178, 30)) ->T : Symbol(T, Decl(immutable.d.ts, 169, 30)) ->otherValue : Symbol(otherValue, Decl(immutable.d.ts, 178, 39)) ->U : Symbol(U, Decl(immutable.d.ts, 178, 12)) ->thirdValue : Symbol(thirdValue, Decl(immutable.d.ts, 178, 54)) ->V : Symbol(V, Decl(immutable.d.ts, 178, 14)) ->Z : Symbol(Z, Decl(immutable.d.ts, 178, 17)) ->otherCollection : Symbol(otherCollection, Decl(immutable.d.ts, 178, 75)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->U : Symbol(U, Decl(immutable.d.ts, 178, 12)) ->thirdCollection : Symbol(thirdCollection, Decl(immutable.d.ts, 178, 112)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->V : Symbol(V, Decl(immutable.d.ts, 178, 14)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->Z : Symbol(Z, Decl(immutable.d.ts, 178, 17)) +>zipWith : Symbol(OrderedSet.zipWith, Decl(immutable.ts, 176, 70), Decl(immutable.ts, 177, 110), Decl(immutable.ts, 178, 165)) +>U : Symbol(U, Decl(immutable.ts, 178, 12)) +>V : Symbol(V, Decl(immutable.ts, 178, 14)) +>Z : Symbol(Z, Decl(immutable.ts, 178, 17)) +>zipper : Symbol(zipper, Decl(immutable.ts, 178, 21)) +>value : Symbol(value, Decl(immutable.ts, 178, 30)) +>T : Symbol(T, Decl(immutable.ts, 169, 30)) +>otherValue : Symbol(otherValue, Decl(immutable.ts, 178, 39)) +>U : Symbol(U, Decl(immutable.ts, 178, 12)) +>thirdValue : Symbol(thirdValue, Decl(immutable.ts, 178, 54)) +>V : Symbol(V, Decl(immutable.ts, 178, 14)) +>Z : Symbol(Z, Decl(immutable.ts, 178, 17)) +>otherCollection : Symbol(otherCollection, Decl(immutable.ts, 178, 75)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>U : Symbol(U, Decl(immutable.ts, 178, 12)) +>thirdCollection : Symbol(thirdCollection, Decl(immutable.ts, 178, 112)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>V : Symbol(V, Decl(immutable.ts, 178, 14)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>Z : Symbol(Z, Decl(immutable.ts, 178, 17)) zipWith(zipper: (...any: Array) => Z, ...collections: Array>): OrderedSet; ->zipWith : Symbol(OrderedSet.zipWith, Decl(immutable.d.ts, 176, 70), Decl(immutable.d.ts, 177, 110), Decl(immutable.d.ts, 178, 165)) ->Z : Symbol(Z, Decl(immutable.d.ts, 179, 12)) ->zipper : Symbol(zipper, Decl(immutable.d.ts, 179, 15)) ->any : Symbol(any, Decl(immutable.d.ts, 179, 24)) +>zipWith : Symbol(OrderedSet.zipWith, Decl(immutable.ts, 176, 70), Decl(immutable.ts, 177, 110), Decl(immutable.ts, 178, 165)) +>Z : Symbol(Z, Decl(immutable.ts, 179, 12)) +>zipper : Symbol(zipper, Decl(immutable.ts, 179, 15)) +>any : Symbol(any, Decl(immutable.ts, 179, 24)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Z : Symbol(Z, Decl(immutable.d.ts, 179, 12)) ->collections : Symbol(collections, Decl(immutable.d.ts, 179, 49)) +>Z : Symbol(Z, Decl(immutable.ts, 179, 12)) +>collections : Symbol(collections, Decl(immutable.ts, 179, 49)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->Z : Symbol(Z, Decl(immutable.d.ts, 179, 12)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>Z : Symbol(Z, Decl(immutable.ts, 179, 12)) } export module Stack { ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) function isStack(maybeStack: any): maybeStack is Stack; ->isStack : Symbol(isStack, Decl(immutable.d.ts, 181, 23)) ->maybeStack : Symbol(maybeStack, Decl(immutable.d.ts, 182, 21)) ->maybeStack : Symbol(maybeStack, Decl(immutable.d.ts, 182, 21)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) +>isStack : Symbol(isStack, Decl(immutable.ts, 181, 23)) +>maybeStack : Symbol(maybeStack, Decl(immutable.ts, 182, 21)) +>maybeStack : Symbol(maybeStack, Decl(immutable.ts, 182, 21)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) function of(...values: Array): Stack; ->of : Symbol(of, Decl(immutable.d.ts, 182, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 183, 16)) ->values : Symbol(values, Decl(immutable.d.ts, 183, 19)) +>of : Symbol(of, Decl(immutable.ts, 182, 64)) +>T : Symbol(T, Decl(immutable.ts, 183, 16)) +>values : Symbol(values, Decl(immutable.ts, 183, 19)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 183, 16)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 183, 16)) +>T : Symbol(T, Decl(immutable.ts, 183, 16)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 183, 16)) } export function Stack(): Stack; ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) export function Stack(): Stack; ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 186, 24)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 186, 24)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 186, 24)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 186, 24)) export function Stack(collection: Iterable): Stack; ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 187, 24)) ->collection : Symbol(collection, Decl(immutable.d.ts, 187, 27)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 187, 24)) +>collection : Symbol(collection, Decl(immutable.ts, 187, 27)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 187, 24)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 187, 24)) +>T : Symbol(T, Decl(immutable.ts, 187, 24)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 187, 24)) export interface Stack extends Collection.Indexed { ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->Collection.Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>Collection.Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) // Reading values peek(): T | undefined; ->peek : Symbol(Stack.peek, Decl(immutable.d.ts, 188, 59)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) +>peek : Symbol(Stack.peek, Decl(immutable.ts, 188, 59)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) // Persistent changes clear(): Stack; ->clear : Symbol(Stack.clear, Decl(immutable.d.ts, 190, 26)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) +>clear : Symbol(Stack.clear, Decl(immutable.ts, 190, 26)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) unshift(...values: Array): Stack; ->unshift : Symbol(Stack.unshift, Decl(immutable.d.ts, 192, 22)) ->values : Symbol(values, Decl(immutable.d.ts, 193, 12)) +>unshift : Symbol(Stack.unshift, Decl(immutable.ts, 192, 22)) +>values : Symbol(values, Decl(immutable.ts, 193, 12)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) unshiftAll(iter: Iterable): Stack; ->unshiftAll : Symbol(Stack.unshiftAll, Decl(immutable.d.ts, 193, 43)) ->iter : Symbol(iter, Decl(immutable.d.ts, 194, 15)) +>unshiftAll : Symbol(Stack.unshiftAll, Decl(immutable.ts, 193, 43)) +>iter : Symbol(iter, Decl(immutable.ts, 194, 15)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) shift(): Stack; ->shift : Symbol(Stack.shift, Decl(immutable.d.ts, 194, 44)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) +>shift : Symbol(Stack.shift, Decl(immutable.ts, 194, 44)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) push(...values: Array): Stack; ->push : Symbol(Stack.push, Decl(immutable.d.ts, 195, 22)) ->values : Symbol(values, Decl(immutable.d.ts, 196, 9)) +>push : Symbol(Stack.push, Decl(immutable.ts, 195, 22)) +>values : Symbol(values, Decl(immutable.ts, 196, 9)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) pushAll(iter: Iterable): Stack; ->pushAll : Symbol(Stack.pushAll, Decl(immutable.d.ts, 196, 40)) ->iter : Symbol(iter, Decl(immutable.d.ts, 197, 12)) +>pushAll : Symbol(Stack.pushAll, Decl(immutable.ts, 196, 40)) +>iter : Symbol(iter, Decl(immutable.ts, 197, 12)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) pop(): Stack; ->pop : Symbol(Stack.pop, Decl(immutable.d.ts, 197, 41)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) +>pop : Symbol(Stack.pop, Decl(immutable.ts, 197, 41)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) // Transient changes withMutations(mutator: (mutable: this) => any): this; ->withMutations : Symbol(Stack.withMutations, Decl(immutable.d.ts, 198, 20)) ->mutator : Symbol(mutator, Decl(immutable.d.ts, 200, 18)) ->mutable : Symbol(mutable, Decl(immutable.d.ts, 200, 28)) +>withMutations : Symbol(Stack.withMutations, Decl(immutable.ts, 198, 20)) +>mutator : Symbol(mutator, Decl(immutable.ts, 200, 18)) +>mutable : Symbol(mutable, Decl(immutable.ts, 200, 28)) asMutable(): this; ->asMutable : Symbol(Stack.asMutable, Decl(immutable.d.ts, 200, 57)) +>asMutable : Symbol(Stack.asMutable, Decl(immutable.ts, 200, 57)) asImmutable(): this; ->asImmutable : Symbol(Stack.asImmutable, Decl(immutable.d.ts, 201, 22)) +>asImmutable : Symbol(Stack.asImmutable, Decl(immutable.ts, 201, 22)) // Sequence algorithms concat(...valuesOrCollections: Array | C>): Stack; ->concat : Symbol(Stack.concat, Decl(immutable.d.ts, 202, 24)) ->C : Symbol(C, Decl(immutable.d.ts, 204, 11)) ->valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.d.ts, 204, 14)) +>concat : Symbol(Stack.concat, Decl(immutable.ts, 202, 24)) +>C : Symbol(C, Decl(immutable.ts, 204, 11)) +>valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.ts, 204, 14)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->C : Symbol(C, Decl(immutable.d.ts, 204, 11)) ->C : Symbol(C, Decl(immutable.d.ts, 204, 11)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->C : Symbol(C, Decl(immutable.d.ts, 204, 11)) +>C : Symbol(C, Decl(immutable.ts, 204, 11)) +>C : Symbol(C, Decl(immutable.ts, 204, 11)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>C : Symbol(C, Decl(immutable.ts, 204, 11)) map(mapper: (value: T, key: number, iter: this) => M, context?: any): Stack; ->map : Symbol(Stack.map, Decl(immutable.d.ts, 204, 76)) ->M : Symbol(M, Decl(immutable.d.ts, 205, 8)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 205, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 205, 20)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 205, 29)) ->iter : Symbol(iter, Decl(immutable.d.ts, 205, 42)) ->M : Symbol(M, Decl(immutable.d.ts, 205, 8)) ->context : Symbol(context, Decl(immutable.d.ts, 205, 60)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->M : Symbol(M, Decl(immutable.d.ts, 205, 8)) +>map : Symbol(Stack.map, Decl(immutable.ts, 204, 76)) +>M : Symbol(M, Decl(immutable.ts, 205, 8)) +>mapper : Symbol(mapper, Decl(immutable.ts, 205, 11)) +>value : Symbol(value, Decl(immutable.ts, 205, 20)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>key : Symbol(key, Decl(immutable.ts, 205, 29)) +>iter : Symbol(iter, Decl(immutable.ts, 205, 42)) +>M : Symbol(M, Decl(immutable.ts, 205, 8)) +>context : Symbol(context, Decl(immutable.ts, 205, 60)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>M : Symbol(M, Decl(immutable.ts, 205, 8)) flatMap(mapper: (value: T, key: number, iter: this) => Iterable, context?: any): Stack; ->flatMap : Symbol(Stack.flatMap, Decl(immutable.d.ts, 205, 86)) ->M : Symbol(M, Decl(immutable.d.ts, 206, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 206, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 206, 24)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 206, 33)) ->iter : Symbol(iter, Decl(immutable.d.ts, 206, 46)) +>flatMap : Symbol(Stack.flatMap, Decl(immutable.ts, 205, 86)) +>M : Symbol(M, Decl(immutable.ts, 206, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 206, 15)) +>value : Symbol(value, Decl(immutable.ts, 206, 24)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>key : Symbol(key, Decl(immutable.ts, 206, 33)) +>iter : Symbol(iter, Decl(immutable.ts, 206, 46)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 206, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 206, 74)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->M : Symbol(M, Decl(immutable.d.ts, 206, 12)) +>M : Symbol(M, Decl(immutable.ts, 206, 12)) +>context : Symbol(context, Decl(immutable.ts, 206, 74)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>M : Symbol(M, Decl(immutable.ts, 206, 12)) filter(predicate: (value: T, index: number, iter: this) => value is F, context?: any): Set; ->filter : Symbol(Stack.filter, Decl(immutable.d.ts, 206, 100), Decl(immutable.d.ts, 207, 111)) ->F : Symbol(F, Decl(immutable.d.ts, 207, 11)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 207, 24)) ->value : Symbol(value, Decl(immutable.d.ts, 207, 36)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->index : Symbol(index, Decl(immutable.d.ts, 207, 45)) ->iter : Symbol(iter, Decl(immutable.d.ts, 207, 60)) ->value : Symbol(value, Decl(immutable.d.ts, 207, 36)) ->F : Symbol(F, Decl(immutable.d.ts, 207, 11)) ->context : Symbol(context, Decl(immutable.d.ts, 207, 87)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->F : Symbol(F, Decl(immutable.d.ts, 207, 11)) +>filter : Symbol(Stack.filter, Decl(immutable.ts, 206, 100), Decl(immutable.ts, 207, 111)) +>F : Symbol(F, Decl(immutable.ts, 207, 11)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>predicate : Symbol(predicate, Decl(immutable.ts, 207, 24)) +>value : Symbol(value, Decl(immutable.ts, 207, 36)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>index : Symbol(index, Decl(immutable.ts, 207, 45)) +>iter : Symbol(iter, Decl(immutable.ts, 207, 60)) +>value : Symbol(value, Decl(immutable.ts, 207, 36)) +>F : Symbol(F, Decl(immutable.ts, 207, 11)) +>context : Symbol(context, Decl(immutable.ts, 207, 87)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>F : Symbol(F, Decl(immutable.ts, 207, 11)) filter(predicate: (value: T, index: number, iter: this) => any, context?: any): this; ->filter : Symbol(Stack.filter, Decl(immutable.d.ts, 206, 100), Decl(immutable.d.ts, 207, 111)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 208, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 208, 23)) ->T : Symbol(T, Decl(immutable.d.ts, 188, 25)) ->index : Symbol(index, Decl(immutable.d.ts, 208, 32)) ->iter : Symbol(iter, Decl(immutable.d.ts, 208, 47)) ->context : Symbol(context, Decl(immutable.d.ts, 208, 67)) +>filter : Symbol(Stack.filter, Decl(immutable.ts, 206, 100), Decl(immutable.ts, 207, 111)) +>predicate : Symbol(predicate, Decl(immutable.ts, 208, 11)) +>value : Symbol(value, Decl(immutable.ts, 208, 23)) +>T : Symbol(T, Decl(immutable.ts, 188, 25)) +>index : Symbol(index, Decl(immutable.ts, 208, 32)) +>iter : Symbol(iter, Decl(immutable.ts, 208, 47)) +>context : Symbol(context, Decl(immutable.ts, 208, 67)) } export function Range(start?: number, end?: number, step?: number): Seq.Indexed; ->Range : Symbol(Range, Decl(immutable.d.ts, 209, 3)) ->start : Symbol(start, Decl(immutable.d.ts, 210, 24)) ->end : Symbol(end, Decl(immutable.d.ts, 210, 39)) ->step : Symbol(step, Decl(immutable.d.ts, 210, 53)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Seq.Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) +>Range : Symbol(Range, Decl(immutable.ts, 209, 3)) +>start : Symbol(start, Decl(immutable.ts, 210, 24)) +>end : Symbol(end, Decl(immutable.ts, 210, 39)) +>step : Symbol(step, Decl(immutable.ts, 210, 53)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Seq.Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) export function Repeat(value: T, times?: number): Seq.Indexed; ->Repeat : Symbol(Repeat, Decl(immutable.d.ts, 210, 90)) ->T : Symbol(T, Decl(immutable.d.ts, 211, 25)) ->value : Symbol(value, Decl(immutable.d.ts, 211, 28)) ->T : Symbol(T, Decl(immutable.d.ts, 211, 25)) ->times : Symbol(times, Decl(immutable.d.ts, 211, 37)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Seq.Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 211, 25)) +>Repeat : Symbol(Repeat, Decl(immutable.ts, 210, 90)) +>T : Symbol(T, Decl(immutable.ts, 211, 25)) +>value : Symbol(value, Decl(immutable.ts, 211, 28)) +>T : Symbol(T, Decl(immutable.ts, 211, 25)) +>times : Symbol(times, Decl(immutable.ts, 211, 37)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Seq.Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 211, 25)) export module Record { ->Record : Symbol(Record, Decl(immutable.d.ts, 211, 70), Decl(immutable.d.ts, 259, 3)) +>Record : Symbol(Record, Decl(immutable.ts, 211, 70), Decl(immutable.ts, 259, 3)) export function isRecord(maybeRecord: any): maybeRecord is Record.Instance; ->isRecord : Symbol(isRecord, Decl(immutable.d.ts, 212, 24)) ->maybeRecord : Symbol(maybeRecord, Decl(immutable.d.ts, 213, 29)) ->maybeRecord : Symbol(maybeRecord, Decl(immutable.d.ts, 213, 29)) ->Record : Symbol(Record, Decl(immutable.d.ts, 211, 70), Decl(immutable.d.ts, 259, 3)) ->Instance : Symbol(Instance, Decl(immutable.d.ts, 218, 5)) +>isRecord : Symbol(isRecord, Decl(immutable.ts, 212, 24)) +>maybeRecord : Symbol(maybeRecord, Decl(immutable.ts, 213, 29)) +>maybeRecord : Symbol(maybeRecord, Decl(immutable.ts, 213, 29)) +>Record : Symbol(Record, Decl(immutable.ts, 211, 70), Decl(immutable.ts, 259, 3)) +>Instance : Symbol(Instance, Decl(immutable.ts, 218, 5)) export function getDescriptiveName(record: Instance): string; ->getDescriptiveName : Symbol(getDescriptiveName, Decl(immutable.d.ts, 213, 84)) ->record : Symbol(record, Decl(immutable.d.ts, 214, 39)) ->Instance : Symbol(Instance, Decl(immutable.d.ts, 218, 5)) +>getDescriptiveName : Symbol(getDescriptiveName, Decl(immutable.ts, 213, 84)) +>record : Symbol(record, Decl(immutable.ts, 214, 39)) +>Instance : Symbol(Instance, Decl(immutable.ts, 218, 5)) export interface Class { ->Class : Symbol(Class, Decl(immutable.d.ts, 214, 70)) ->T : Symbol(T, Decl(immutable.d.ts, 215, 27)) +>Class : Symbol(Class, Decl(immutable.ts, 214, 70)) +>T : Symbol(T, Decl(immutable.ts, 215, 27)) >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) (values?: Partial | Iterable<[string, any]>): Instance & Readonly; ->values : Symbol(values, Decl(immutable.d.ts, 216, 7)) +>values : Symbol(values, Decl(immutable.ts, 216, 7)) >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 215, 27)) +>T : Symbol(T, Decl(immutable.ts, 215, 27)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Instance : Symbol(Instance, Decl(immutable.d.ts, 218, 5)) ->T : Symbol(T, Decl(immutable.d.ts, 215, 27)) +>Instance : Symbol(Instance, Decl(immutable.ts, 218, 5)) +>T : Symbol(T, Decl(immutable.ts, 215, 27)) >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 215, 27)) +>T : Symbol(T, Decl(immutable.ts, 215, 27)) new (values?: Partial | Iterable<[string, any]>): Instance & Readonly; ->values : Symbol(values, Decl(immutable.d.ts, 217, 11)) +>values : Symbol(values, Decl(immutable.ts, 217, 11)) >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 215, 27)) +>T : Symbol(T, Decl(immutable.ts, 215, 27)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Instance : Symbol(Instance, Decl(immutable.d.ts, 218, 5)) ->T : Symbol(T, Decl(immutable.d.ts, 215, 27)) +>Instance : Symbol(Instance, Decl(immutable.ts, 218, 5)) +>T : Symbol(T, Decl(immutable.ts, 215, 27)) >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 215, 27)) +>T : Symbol(T, Decl(immutable.ts, 215, 27)) } export interface Instance { ->Instance : Symbol(Instance, Decl(immutable.d.ts, 218, 5)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>Instance : Symbol(Instance, Decl(immutable.ts, 218, 5)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) readonly size: number; ->size : Symbol(Instance.size, Decl(immutable.d.ts, 219, 49)) +>size : Symbol(Instance.size, Decl(immutable.ts, 219, 49)) // Reading values has(key: string): boolean; ->has : Symbol(Instance.has, Decl(immutable.d.ts, 220, 28)) ->key : Symbol(key, Decl(immutable.d.ts, 222, 10)) +>has : Symbol(Instance.has, Decl(immutable.ts, 220, 28)) +>key : Symbol(key, Decl(immutable.ts, 222, 10)) get(key: K): T[K]; ->get : Symbol(Instance.get, Decl(immutable.d.ts, 222, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 223, 10)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->key : Symbol(key, Decl(immutable.d.ts, 223, 29)) ->K : Symbol(K, Decl(immutable.d.ts, 223, 10)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->K : Symbol(K, Decl(immutable.d.ts, 223, 10)) +>get : Symbol(Instance.get, Decl(immutable.ts, 222, 32)) +>K : Symbol(K, Decl(immutable.ts, 223, 10)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>key : Symbol(key, Decl(immutable.ts, 223, 29)) +>K : Symbol(K, Decl(immutable.ts, 223, 10)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>K : Symbol(K, Decl(immutable.ts, 223, 10)) // Reading deep values hasIn(keyPath: Iterable): boolean; ->hasIn : Symbol(Instance.hasIn, Decl(immutable.d.ts, 223, 43)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 225, 12)) +>hasIn : Symbol(Instance.hasIn, Decl(immutable.ts, 223, 43)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 225, 12)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) getIn(keyPath: Iterable): any; ->getIn : Symbol(Instance.getIn, Decl(immutable.d.ts, 225, 45)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 226, 12)) +>getIn : Symbol(Instance.getIn, Decl(immutable.ts, 225, 45)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 226, 12)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) // Value equality equals(other: any): boolean; ->equals : Symbol(Instance.equals, Decl(immutable.d.ts, 226, 41)) ->other : Symbol(other, Decl(immutable.d.ts, 228, 13)) +>equals : Symbol(Instance.equals, Decl(immutable.ts, 226, 41)) +>other : Symbol(other, Decl(immutable.ts, 228, 13)) hashCode(): number; ->hashCode : Symbol(Instance.hashCode, Decl(immutable.d.ts, 228, 34)) +>hashCode : Symbol(Instance.hashCode, Decl(immutable.ts, 228, 34)) // Persistent changes set(key: K, value: T[K]): this; ->set : Symbol(Instance.set, Decl(immutable.d.ts, 229, 25)) ->K : Symbol(K, Decl(immutable.d.ts, 231, 10)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->key : Symbol(key, Decl(immutable.d.ts, 231, 29)) ->K : Symbol(K, Decl(immutable.d.ts, 231, 10)) ->value : Symbol(value, Decl(immutable.d.ts, 231, 36)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->K : Symbol(K, Decl(immutable.d.ts, 231, 10)) +>set : Symbol(Instance.set, Decl(immutable.ts, 229, 25)) +>K : Symbol(K, Decl(immutable.ts, 231, 10)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>key : Symbol(key, Decl(immutable.ts, 231, 29)) +>K : Symbol(K, Decl(immutable.ts, 231, 10)) +>value : Symbol(value, Decl(immutable.ts, 231, 36)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>K : Symbol(K, Decl(immutable.ts, 231, 10)) update(key: K, updater: (value: T[K]) => T[K]): this; ->update : Symbol(Instance.update, Decl(immutable.d.ts, 231, 56)) ->K : Symbol(K, Decl(immutable.d.ts, 232, 13)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->key : Symbol(key, Decl(immutable.d.ts, 232, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 232, 13)) ->updater : Symbol(updater, Decl(immutable.d.ts, 232, 39)) ->value : Symbol(value, Decl(immutable.d.ts, 232, 50)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->K : Symbol(K, Decl(immutable.d.ts, 232, 13)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->K : Symbol(K, Decl(immutable.d.ts, 232, 13)) +>update : Symbol(Instance.update, Decl(immutable.ts, 231, 56)) +>K : Symbol(K, Decl(immutable.ts, 232, 13)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>key : Symbol(key, Decl(immutable.ts, 232, 32)) +>K : Symbol(K, Decl(immutable.ts, 232, 13)) +>updater : Symbol(updater, Decl(immutable.ts, 232, 39)) +>value : Symbol(value, Decl(immutable.ts, 232, 50)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>K : Symbol(K, Decl(immutable.ts, 232, 13)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>K : Symbol(K, Decl(immutable.ts, 232, 13)) merge(...collections: Array | Iterable<[string, any]>>): this; ->merge : Symbol(Instance.merge, Decl(immutable.d.ts, 232, 78)) ->collections : Symbol(collections, Decl(immutable.d.ts, 233, 12)) +>merge : Symbol(Instance.merge, Decl(immutable.ts, 232, 78)) +>collections : Symbol(collections, Decl(immutable.ts, 233, 12)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) mergeDeep(...collections: Array | Iterable<[string, any]>>): this; ->mergeDeep : Symbol(Instance.mergeDeep, Decl(immutable.d.ts, 233, 79)) ->collections : Symbol(collections, Decl(immutable.d.ts, 234, 16)) +>mergeDeep : Symbol(Instance.mergeDeep, Decl(immutable.ts, 233, 79)) +>collections : Symbol(collections, Decl(immutable.ts, 234, 16)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) mergeWith(merger: (oldVal: any, newVal: any, key: keyof T) => any, ...collections: Array | Iterable<[string, any]>>): this; ->mergeWith : Symbol(Instance.mergeWith, Decl(immutable.d.ts, 234, 83)) ->merger : Symbol(merger, Decl(immutable.d.ts, 235, 16)) ->oldVal : Symbol(oldVal, Decl(immutable.d.ts, 235, 25)) ->newVal : Symbol(newVal, Decl(immutable.d.ts, 235, 37)) ->key : Symbol(key, Decl(immutable.d.ts, 235, 50)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->collections : Symbol(collections, Decl(immutable.d.ts, 235, 72)) +>mergeWith : Symbol(Instance.mergeWith, Decl(immutable.ts, 234, 83)) +>merger : Symbol(merger, Decl(immutable.ts, 235, 16)) +>oldVal : Symbol(oldVal, Decl(immutable.ts, 235, 25)) +>newVal : Symbol(newVal, Decl(immutable.ts, 235, 37)) +>key : Symbol(key, Decl(immutable.ts, 235, 50)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>collections : Symbol(collections, Decl(immutable.ts, 235, 72)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) mergeDeepWith(merger: (oldVal: any, newVal: any, key: any) => any, ...collections: Array | Iterable<[string, any]>>): this; ->mergeDeepWith : Symbol(Instance.mergeDeepWith, Decl(immutable.d.ts, 235, 140)) ->merger : Symbol(merger, Decl(immutable.d.ts, 236, 20)) ->oldVal : Symbol(oldVal, Decl(immutable.d.ts, 236, 29)) ->newVal : Symbol(newVal, Decl(immutable.d.ts, 236, 41)) ->key : Symbol(key, Decl(immutable.d.ts, 236, 54)) ->collections : Symbol(collections, Decl(immutable.d.ts, 236, 72)) +>mergeDeepWith : Symbol(Instance.mergeDeepWith, Decl(immutable.ts, 235, 140)) +>merger : Symbol(merger, Decl(immutable.ts, 236, 20)) +>oldVal : Symbol(oldVal, Decl(immutable.ts, 236, 29)) +>newVal : Symbol(newVal, Decl(immutable.ts, 236, 41)) +>key : Symbol(key, Decl(immutable.ts, 236, 54)) +>collections : Symbol(collections, Decl(immutable.ts, 236, 72)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) delete(key: K): this; ->delete : Symbol(Instance.delete, Decl(immutable.d.ts, 236, 140)) ->K : Symbol(K, Decl(immutable.d.ts, 237, 13)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->key : Symbol(key, Decl(immutable.d.ts, 237, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 237, 13)) +>delete : Symbol(Instance.delete, Decl(immutable.ts, 236, 140)) +>K : Symbol(K, Decl(immutable.ts, 237, 13)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>key : Symbol(key, Decl(immutable.ts, 237, 32)) +>K : Symbol(K, Decl(immutable.ts, 237, 13)) remove(key: K): this; ->remove : Symbol(Instance.remove, Decl(immutable.d.ts, 237, 46)) ->K : Symbol(K, Decl(immutable.d.ts, 238, 13)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->key : Symbol(key, Decl(immutable.d.ts, 238, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 238, 13)) +>remove : Symbol(Instance.remove, Decl(immutable.ts, 237, 46)) +>K : Symbol(K, Decl(immutable.ts, 238, 13)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>key : Symbol(key, Decl(immutable.ts, 238, 32)) +>K : Symbol(K, Decl(immutable.ts, 238, 13)) clear(): this; ->clear : Symbol(Instance.clear, Decl(immutable.d.ts, 238, 46)) +>clear : Symbol(Instance.clear, Decl(immutable.ts, 238, 46)) // Deep persistent changes setIn(keyPath: Iterable, value: any): this; ->setIn : Symbol(Instance.setIn, Decl(immutable.d.ts, 239, 20)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 241, 12)) +>setIn : Symbol(Instance.setIn, Decl(immutable.ts, 239, 20)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 241, 12)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->value : Symbol(value, Decl(immutable.d.ts, 241, 35)) +>value : Symbol(value, Decl(immutable.ts, 241, 35)) updateIn(keyPath: Iterable, updater: (value: any) => any): this; ->updateIn : Symbol(Instance.updateIn, Decl(immutable.d.ts, 241, 54)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 242, 15)) +>updateIn : Symbol(Instance.updateIn, Decl(immutable.ts, 241, 54)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 242, 15)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->updater : Symbol(updater, Decl(immutable.d.ts, 242, 38)) ->value : Symbol(value, Decl(immutable.d.ts, 242, 49)) +>updater : Symbol(updater, Decl(immutable.ts, 242, 38)) +>value : Symbol(value, Decl(immutable.ts, 242, 49)) mergeIn(keyPath: Iterable, ...collections: Array): this; ->mergeIn : Symbol(Instance.mergeIn, Decl(immutable.d.ts, 242, 75)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 243, 14)) +>mergeIn : Symbol(Instance.mergeIn, Decl(immutable.ts, 242, 75)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 243, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->collections : Symbol(collections, Decl(immutable.d.ts, 243, 37)) +>collections : Symbol(collections, Decl(immutable.ts, 243, 37)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) mergeDeepIn(keyPath: Iterable, ...collections: Array): this; ->mergeDeepIn : Symbol(Instance.mergeDeepIn, Decl(immutable.d.ts, 243, 72)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 244, 18)) +>mergeDeepIn : Symbol(Instance.mergeDeepIn, Decl(immutable.ts, 243, 72)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 244, 18)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->collections : Symbol(collections, Decl(immutable.d.ts, 244, 41)) +>collections : Symbol(collections, Decl(immutable.ts, 244, 41)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) deleteIn(keyPath: Iterable): this; ->deleteIn : Symbol(Instance.deleteIn, Decl(immutable.d.ts, 244, 76)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 245, 15)) +>deleteIn : Symbol(Instance.deleteIn, Decl(immutable.ts, 244, 76)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 245, 15)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) removeIn(keyPath: Iterable): this; ->removeIn : Symbol(Instance.removeIn, Decl(immutable.d.ts, 245, 45)) ->keyPath : Symbol(keyPath, Decl(immutable.d.ts, 246, 15)) +>removeIn : Symbol(Instance.removeIn, Decl(immutable.ts, 245, 45)) +>keyPath : Symbol(keyPath, Decl(immutable.ts, 246, 15)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) // Conversion to JavaScript types toJS(): { [K in keyof T]: any }; ->toJS : Symbol(Instance.toJS, Decl(immutable.d.ts, 246, 45)) ->K : Symbol(K, Decl(immutable.d.ts, 248, 17)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>toJS : Symbol(Instance.toJS, Decl(immutable.ts, 246, 45)) +>K : Symbol(K, Decl(immutable.ts, 248, 17)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) toJSON(): T; ->toJSON : Symbol(Instance.toJSON, Decl(immutable.d.ts, 248, 38)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>toJSON : Symbol(Instance.toJSON, Decl(immutable.ts, 248, 38)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) toObject(): T; ->toObject : Symbol(Instance.toObject, Decl(immutable.d.ts, 249, 18)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>toObject : Symbol(Instance.toObject, Decl(immutable.ts, 249, 18)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) // Transient changes withMutations(mutator: (mutable: this) => any): this; ->withMutations : Symbol(Instance.withMutations, Decl(immutable.d.ts, 250, 20)) ->mutator : Symbol(mutator, Decl(immutable.d.ts, 252, 20)) ->mutable : Symbol(mutable, Decl(immutable.d.ts, 252, 30)) +>withMutations : Symbol(Instance.withMutations, Decl(immutable.ts, 250, 20)) +>mutator : Symbol(mutator, Decl(immutable.ts, 252, 20)) +>mutable : Symbol(mutable, Decl(immutable.ts, 252, 30)) asMutable(): this; ->asMutable : Symbol(Instance.asMutable, Decl(immutable.d.ts, 252, 59)) +>asMutable : Symbol(Instance.asMutable, Decl(immutable.ts, 252, 59)) asImmutable(): this; ->asImmutable : Symbol(Instance.asImmutable, Decl(immutable.d.ts, 253, 24)) +>asImmutable : Symbol(Instance.asImmutable, Decl(immutable.ts, 253, 24)) // Sequence algorithms toSeq(): Seq.Keyed; ->toSeq : Symbol(Instance.toSeq, Decl(immutable.d.ts, 254, 26)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Seq.Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>toSeq : Symbol(Instance.toSeq, Decl(immutable.ts, 254, 26)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Seq.Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) [Symbol.iterator](): IterableIterator<[keyof T, T[keyof T]]>; >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) ->T : Symbol(T, Decl(immutable.d.ts, 219, 30)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) +>T : Symbol(T, Decl(immutable.ts, 219, 30)) } } export function Record(defaultValues: T, name?: string): Record.Class; ->Record : Symbol(Record, Decl(immutable.d.ts, 211, 70), Decl(immutable.d.ts, 259, 3)) ->T : Symbol(T, Decl(immutable.d.ts, 260, 25)) ->defaultValues : Symbol(defaultValues, Decl(immutable.d.ts, 260, 28)) ->T : Symbol(T, Decl(immutable.d.ts, 260, 25)) ->name : Symbol(name, Decl(immutable.d.ts, 260, 45)) ->Record : Symbol(Record, Decl(immutable.d.ts, 211, 70), Decl(immutable.d.ts, 259, 3)) ->Class : Symbol(Record.Class, Decl(immutable.d.ts, 214, 70)) ->T : Symbol(T, Decl(immutable.d.ts, 260, 25)) +>Record : Symbol(Record, Decl(immutable.ts, 211, 70), Decl(immutable.ts, 259, 3)) +>T : Symbol(T, Decl(immutable.ts, 260, 25)) +>defaultValues : Symbol(defaultValues, Decl(immutable.ts, 260, 28)) +>T : Symbol(T, Decl(immutable.ts, 260, 25)) +>name : Symbol(name, Decl(immutable.ts, 260, 45)) +>Record : Symbol(Record, Decl(immutable.ts, 211, 70), Decl(immutable.ts, 259, 3)) +>Class : Symbol(Record.Class, Decl(immutable.ts, 214, 70)) +>T : Symbol(T, Decl(immutable.ts, 260, 25)) export module Seq { ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) function isSeq(maybeSeq: any): maybeSeq is Seq.Indexed | Seq.Keyed; ->isSeq : Symbol(isSeq, Decl(immutable.d.ts, 261, 21)) ->maybeSeq : Symbol(maybeSeq, Decl(immutable.d.ts, 262, 19)) ->maybeSeq : Symbol(maybeSeq, Decl(immutable.d.ts, 262, 19)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) +>isSeq : Symbol(isSeq, Decl(immutable.ts, 261, 21)) +>maybeSeq : Symbol(maybeSeq, Decl(immutable.ts, 262, 19)) +>maybeSeq : Symbol(maybeSeq, Decl(immutable.ts, 262, 19)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) function of(...values: Array): Seq.Indexed; ->of : Symbol(of, Decl(immutable.d.ts, 262, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 263, 16)) ->values : Symbol(values, Decl(immutable.d.ts, 263, 19)) +>of : Symbol(of, Decl(immutable.ts, 262, 86)) +>T : Symbol(T, Decl(immutable.ts, 263, 16)) +>values : Symbol(values, Decl(immutable.ts, 263, 19)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 263, 16)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 263, 16)) +>T : Symbol(T, Decl(immutable.ts, 263, 16)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 263, 16)) export module Keyed {} ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) export function Keyed(collection: Iterable<[K, V]>): Seq.Keyed; ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 265, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 265, 28)) ->collection : Symbol(collection, Decl(immutable.d.ts, 265, 32)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 265, 26)) +>V : Symbol(V, Decl(immutable.ts, 265, 28)) +>collection : Symbol(collection, Decl(immutable.ts, 265, 32)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->K : Symbol(K, Decl(immutable.d.ts, 265, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 265, 28)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 265, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 265, 28)) +>K : Symbol(K, Decl(immutable.ts, 265, 26)) +>V : Symbol(V, Decl(immutable.ts, 265, 28)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 265, 26)) +>V : Symbol(V, Decl(immutable.ts, 265, 28)) export function Keyed(obj: {[key: string]: V}): Seq.Keyed; ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->V : Symbol(V, Decl(immutable.d.ts, 266, 26)) ->obj : Symbol(obj, Decl(immutable.d.ts, 266, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 266, 36)) ->V : Symbol(V, Decl(immutable.d.ts, 266, 26)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->V : Symbol(V, Decl(immutable.d.ts, 266, 26)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>V : Symbol(V, Decl(immutable.ts, 266, 26)) +>obj : Symbol(obj, Decl(immutable.ts, 266, 29)) +>key : Symbol(key, Decl(immutable.ts, 266, 36)) +>V : Symbol(V, Decl(immutable.ts, 266, 26)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>V : Symbol(V, Decl(immutable.ts, 266, 26)) export function Keyed(): Seq.Keyed; ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 267, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 267, 28)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 267, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 267, 28)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 267, 26)) +>V : Symbol(V, Decl(immutable.ts, 267, 28)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 267, 26)) +>V : Symbol(V, Decl(immutable.ts, 267, 28)) export function Keyed(): Seq.Keyed; ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) export interface Keyed extends Seq, Collection.Keyed { ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->Collection.Keyed : Symbol(Collection.Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Collection.Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>Collection.Keyed : Symbol(Collection.Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Collection.Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) toJS(): Object; ->toJS : Symbol(Keyed.toJS, Decl(immutable.d.ts, 269, 76)) +>toJS : Symbol(Keyed.toJS, Decl(immutable.ts, 269, 76)) >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) toJSON(): { [key: string]: V }; ->toJSON : Symbol(Keyed.toJSON, Decl(immutable.d.ts, 270, 21)) ->key : Symbol(key, Decl(immutable.d.ts, 271, 19)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) +>toJSON : Symbol(Keyed.toJSON, Decl(immutable.ts, 270, 21)) +>key : Symbol(key, Decl(immutable.ts, 271, 19)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) toSeq(): this; ->toSeq : Symbol(Keyed.toSeq, Decl(immutable.d.ts, 271, 37)) +>toSeq : Symbol(Keyed.toSeq, Decl(immutable.ts, 271, 37)) concat(...collections: Array>): Seq.Keyed; ->concat : Symbol(Keyed.concat, Decl(immutable.d.ts, 272, 20), Decl(immutable.d.ts, 273, 91)) ->KC : Symbol(KC, Decl(immutable.d.ts, 273, 13)) ->VC : Symbol(VC, Decl(immutable.d.ts, 273, 16)) ->collections : Symbol(collections, Decl(immutable.d.ts, 273, 21)) +>concat : Symbol(Keyed.concat, Decl(immutable.ts, 272, 20), Decl(immutable.ts, 273, 91)) +>KC : Symbol(KC, Decl(immutable.ts, 273, 13)) +>VC : Symbol(VC, Decl(immutable.ts, 273, 16)) +>collections : Symbol(collections, Decl(immutable.ts, 273, 21)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->KC : Symbol(KC, Decl(immutable.d.ts, 273, 13)) ->VC : Symbol(VC, Decl(immutable.d.ts, 273, 16)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->KC : Symbol(KC, Decl(immutable.d.ts, 273, 13)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->VC : Symbol(VC, Decl(immutable.d.ts, 273, 16)) +>KC : Symbol(KC, Decl(immutable.ts, 273, 13)) +>VC : Symbol(VC, Decl(immutable.ts, 273, 16)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>KC : Symbol(KC, Decl(immutable.ts, 273, 13)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>VC : Symbol(VC, Decl(immutable.ts, 273, 16)) concat(...collections: Array<{[key: string]: C}>): Seq.Keyed; ->concat : Symbol(Keyed.concat, Decl(immutable.d.ts, 272, 20), Decl(immutable.d.ts, 273, 91)) ->C : Symbol(C, Decl(immutable.d.ts, 274, 13)) ->collections : Symbol(collections, Decl(immutable.d.ts, 274, 16)) +>concat : Symbol(Keyed.concat, Decl(immutable.ts, 272, 20), Decl(immutable.ts, 273, 91)) +>C : Symbol(C, Decl(immutable.ts, 274, 13)) +>collections : Symbol(collections, Decl(immutable.ts, 274, 16)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->key : Symbol(key, Decl(immutable.d.ts, 274, 40)) ->C : Symbol(C, Decl(immutable.d.ts, 274, 13)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->C : Symbol(C, Decl(immutable.d.ts, 274, 13)) +>key : Symbol(key, Decl(immutable.ts, 274, 40)) +>C : Symbol(C, Decl(immutable.ts, 274, 13)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>C : Symbol(C, Decl(immutable.ts, 274, 13)) map(mapper: (value: V, key: K, iter: this) => M, context?: any): Seq.Keyed; ->map : Symbol(Keyed.map, Decl(immutable.d.ts, 274, 89)) ->M : Symbol(M, Decl(immutable.d.ts, 275, 10)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 275, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 275, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 275, 31)) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->iter : Symbol(iter, Decl(immutable.d.ts, 275, 39)) ->M : Symbol(M, Decl(immutable.d.ts, 275, 10)) ->context : Symbol(context, Decl(immutable.d.ts, 275, 57)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->M : Symbol(M, Decl(immutable.d.ts, 275, 10)) +>map : Symbol(Keyed.map, Decl(immutable.ts, 274, 89)) +>M : Symbol(M, Decl(immutable.ts, 275, 10)) +>mapper : Symbol(mapper, Decl(immutable.ts, 275, 13)) +>value : Symbol(value, Decl(immutable.ts, 275, 22)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>key : Symbol(key, Decl(immutable.ts, 275, 31)) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>iter : Symbol(iter, Decl(immutable.ts, 275, 39)) +>M : Symbol(M, Decl(immutable.ts, 275, 10)) +>context : Symbol(context, Decl(immutable.ts, 275, 57)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>M : Symbol(M, Decl(immutable.ts, 275, 10)) mapKeys(mapper: (key: K, value: V, iter: this) => M, context?: any): Seq.Keyed; ->mapKeys : Symbol(Keyed.mapKeys, Decl(immutable.d.ts, 275, 90)) ->M : Symbol(M, Decl(immutable.d.ts, 276, 14)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 276, 17)) ->key : Symbol(key, Decl(immutable.d.ts, 276, 26)) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->value : Symbol(value, Decl(immutable.d.ts, 276, 33)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->iter : Symbol(iter, Decl(immutable.d.ts, 276, 43)) ->M : Symbol(M, Decl(immutable.d.ts, 276, 14)) ->context : Symbol(context, Decl(immutable.d.ts, 276, 61)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->M : Symbol(M, Decl(immutable.d.ts, 276, 14)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) +>mapKeys : Symbol(Keyed.mapKeys, Decl(immutable.ts, 275, 90)) +>M : Symbol(M, Decl(immutable.ts, 276, 14)) +>mapper : Symbol(mapper, Decl(immutable.ts, 276, 17)) +>key : Symbol(key, Decl(immutable.ts, 276, 26)) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>value : Symbol(value, Decl(immutable.ts, 276, 33)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>iter : Symbol(iter, Decl(immutable.ts, 276, 43)) +>M : Symbol(M, Decl(immutable.ts, 276, 14)) +>context : Symbol(context, Decl(immutable.ts, 276, 61)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>M : Symbol(M, Decl(immutable.ts, 276, 14)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) mapEntries(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], context?: any): Seq.Keyed; ->mapEntries : Symbol(Keyed.mapEntries, Decl(immutable.d.ts, 276, 94)) ->KM : Symbol(KM, Decl(immutable.d.ts, 277, 17)) ->VM : Symbol(VM, Decl(immutable.d.ts, 277, 20)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 277, 25)) ->entry : Symbol(entry, Decl(immutable.d.ts, 277, 34)) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->index : Symbol(index, Decl(immutable.d.ts, 277, 48)) ->iter : Symbol(iter, Decl(immutable.d.ts, 277, 63)) ->KM : Symbol(KM, Decl(immutable.d.ts, 277, 17)) ->VM : Symbol(VM, Decl(immutable.d.ts, 277, 20)) ->context : Symbol(context, Decl(immutable.d.ts, 277, 88)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->KM : Symbol(KM, Decl(immutable.d.ts, 277, 17)) ->VM : Symbol(VM, Decl(immutable.d.ts, 277, 20)) +>mapEntries : Symbol(Keyed.mapEntries, Decl(immutable.ts, 276, 94)) +>KM : Symbol(KM, Decl(immutable.ts, 277, 17)) +>VM : Symbol(VM, Decl(immutable.ts, 277, 20)) +>mapper : Symbol(mapper, Decl(immutable.ts, 277, 25)) +>entry : Symbol(entry, Decl(immutable.ts, 277, 34)) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>index : Symbol(index, Decl(immutable.ts, 277, 48)) +>iter : Symbol(iter, Decl(immutable.ts, 277, 63)) +>KM : Symbol(KM, Decl(immutable.ts, 277, 17)) +>VM : Symbol(VM, Decl(immutable.ts, 277, 20)) +>context : Symbol(context, Decl(immutable.ts, 277, 88)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>KM : Symbol(KM, Decl(immutable.ts, 277, 17)) +>VM : Symbol(VM, Decl(immutable.ts, 277, 20)) flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Seq.Keyed; ->flatMap : Symbol(Keyed.flatMap, Decl(immutable.d.ts, 277, 123)) ->M : Symbol(M, Decl(immutable.d.ts, 278, 14)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 278, 17)) ->value : Symbol(value, Decl(immutable.d.ts, 278, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 278, 35)) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->iter : Symbol(iter, Decl(immutable.d.ts, 278, 43)) +>flatMap : Symbol(Keyed.flatMap, Decl(immutable.ts, 277, 123)) +>M : Symbol(M, Decl(immutable.ts, 278, 14)) +>mapper : Symbol(mapper, Decl(immutable.ts, 278, 17)) +>value : Symbol(value, Decl(immutable.ts, 278, 26)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>key : Symbol(key, Decl(immutable.ts, 278, 35)) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>iter : Symbol(iter, Decl(immutable.ts, 278, 43)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 278, 14)) ->context : Symbol(context, Decl(immutable.d.ts, 278, 71)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) +>M : Symbol(M, Decl(immutable.ts, 278, 14)) +>context : Symbol(context, Decl(immutable.ts, 278, 71)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Seq.Keyed; ->filter : Symbol(Keyed.filter, Decl(immutable.d.ts, 278, 108), Decl(immutable.d.ts, 279, 115)) ->F : Symbol(F, Decl(immutable.d.ts, 279, 13)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 279, 26)) ->value : Symbol(value, Decl(immutable.d.ts, 279, 38)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 279, 47)) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->iter : Symbol(iter, Decl(immutable.d.ts, 279, 55)) ->value : Symbol(value, Decl(immutable.d.ts, 279, 38)) ->F : Symbol(F, Decl(immutable.d.ts, 279, 13)) ->context : Symbol(context, Decl(immutable.d.ts, 279, 82)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->F : Symbol(F, Decl(immutable.d.ts, 279, 13)) +>filter : Symbol(Keyed.filter, Decl(immutable.ts, 278, 108), Decl(immutable.ts, 279, 115)) +>F : Symbol(F, Decl(immutable.ts, 279, 13)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>predicate : Symbol(predicate, Decl(immutable.ts, 279, 26)) +>value : Symbol(value, Decl(immutable.ts, 279, 38)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>key : Symbol(key, Decl(immutable.ts, 279, 47)) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>iter : Symbol(iter, Decl(immutable.ts, 279, 55)) +>value : Symbol(value, Decl(immutable.ts, 279, 38)) +>F : Symbol(F, Decl(immutable.ts, 279, 13)) +>context : Symbol(context, Decl(immutable.ts, 279, 82)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>F : Symbol(F, Decl(immutable.ts, 279, 13)) filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; ->filter : Symbol(Keyed.filter, Decl(immutable.d.ts, 278, 108), Decl(immutable.d.ts, 279, 115)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 280, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 280, 25)) ->V : Symbol(V, Decl(immutable.d.ts, 269, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 280, 34)) ->K : Symbol(K, Decl(immutable.d.ts, 269, 27)) ->iter : Symbol(iter, Decl(immutable.d.ts, 280, 42)) ->context : Symbol(context, Decl(immutable.d.ts, 280, 62)) +>filter : Symbol(Keyed.filter, Decl(immutable.ts, 278, 108), Decl(immutable.ts, 279, 115)) +>predicate : Symbol(predicate, Decl(immutable.ts, 280, 13)) +>value : Symbol(value, Decl(immutable.ts, 280, 25)) +>V : Symbol(V, Decl(immutable.ts, 269, 29)) +>key : Symbol(key, Decl(immutable.ts, 280, 34)) +>K : Symbol(K, Decl(immutable.ts, 269, 27)) +>iter : Symbol(iter, Decl(immutable.ts, 280, 42)) +>context : Symbol(context, Decl(immutable.ts, 280, 62)) } module Indexed { ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) function of(...values: Array): Seq.Indexed; ->of : Symbol(of, Decl(immutable.d.ts, 282, 20)) ->T : Symbol(T, Decl(immutable.d.ts, 283, 18)) ->values : Symbol(values, Decl(immutable.d.ts, 283, 21)) +>of : Symbol(of, Decl(immutable.ts, 282, 20)) +>T : Symbol(T, Decl(immutable.ts, 283, 18)) +>values : Symbol(values, Decl(immutable.ts, 283, 21)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 283, 18)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 283, 18)) +>T : Symbol(T, Decl(immutable.ts, 283, 18)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 283, 18)) } export function Indexed(): Seq.Indexed; ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) export function Indexed(): Seq.Indexed; ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 286, 28)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 286, 28)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 286, 28)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 286, 28)) export function Indexed(collection: Iterable): Seq.Indexed; ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 287, 28)) ->collection : Symbol(collection, Decl(immutable.d.ts, 287, 31)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 287, 28)) +>collection : Symbol(collection, Decl(immutable.ts, 287, 31)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 287, 28)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 287, 28)) +>T : Symbol(T, Decl(immutable.ts, 287, 28)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 287, 28)) export interface Indexed extends Seq, Collection.Indexed { ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) ->Collection.Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) +>Collection.Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) toJS(): Array; ->toJS : Symbol(Indexed.toJS, Decl(immutable.d.ts, 288, 79)) +>toJS : Symbol(Indexed.toJS, Decl(immutable.ts, 288, 79)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) toJSON(): Array; ->toJSON : Symbol(Indexed.toJSON, Decl(immutable.d.ts, 289, 25)) +>toJSON : Symbol(Indexed.toJSON, Decl(immutable.ts, 289, 25)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) toSeq(): this; ->toSeq : Symbol(Indexed.toSeq, Decl(immutable.d.ts, 290, 25)) +>toSeq : Symbol(Indexed.toSeq, Decl(immutable.ts, 290, 25)) concat(...valuesOrCollections: Array | C>): Seq.Indexed; ->concat : Symbol(Indexed.concat, Decl(immutable.d.ts, 291, 20)) ->C : Symbol(C, Decl(immutable.d.ts, 292, 13)) ->valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.d.ts, 292, 16)) +>concat : Symbol(Indexed.concat, Decl(immutable.ts, 291, 20)) +>C : Symbol(C, Decl(immutable.ts, 292, 13)) +>valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.ts, 292, 16)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->C : Symbol(C, Decl(immutable.d.ts, 292, 13)) ->C : Symbol(C, Decl(immutable.d.ts, 292, 13)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) ->C : Symbol(C, Decl(immutable.d.ts, 292, 13)) +>C : Symbol(C, Decl(immutable.ts, 292, 13)) +>C : Symbol(C, Decl(immutable.ts, 292, 13)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) +>C : Symbol(C, Decl(immutable.ts, 292, 13)) map(mapper: (value: T, key: number, iter: this) => M, context?: any): Seq.Indexed; ->map : Symbol(Indexed.map, Decl(immutable.d.ts, 292, 84)) ->M : Symbol(M, Decl(immutable.d.ts, 293, 10)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 293, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 293, 22)) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 293, 31)) ->iter : Symbol(iter, Decl(immutable.d.ts, 293, 44)) ->M : Symbol(M, Decl(immutable.d.ts, 293, 10)) ->context : Symbol(context, Decl(immutable.d.ts, 293, 62)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->M : Symbol(M, Decl(immutable.d.ts, 293, 10)) +>map : Symbol(Indexed.map, Decl(immutable.ts, 292, 84)) +>M : Symbol(M, Decl(immutable.ts, 293, 10)) +>mapper : Symbol(mapper, Decl(immutable.ts, 293, 13)) +>value : Symbol(value, Decl(immutable.ts, 293, 22)) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) +>key : Symbol(key, Decl(immutable.ts, 293, 31)) +>iter : Symbol(iter, Decl(immutable.ts, 293, 44)) +>M : Symbol(M, Decl(immutable.ts, 293, 10)) +>context : Symbol(context, Decl(immutable.ts, 293, 62)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>M : Symbol(M, Decl(immutable.ts, 293, 10)) flatMap(mapper: (value: T, key: number, iter: this) => Iterable, context?: any): Seq.Indexed; ->flatMap : Symbol(Indexed.flatMap, Decl(immutable.d.ts, 293, 94)) ->M : Symbol(M, Decl(immutable.d.ts, 294, 14)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 294, 17)) ->value : Symbol(value, Decl(immutable.d.ts, 294, 26)) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 294, 35)) ->iter : Symbol(iter, Decl(immutable.d.ts, 294, 48)) +>flatMap : Symbol(Indexed.flatMap, Decl(immutable.ts, 293, 94)) +>M : Symbol(M, Decl(immutable.ts, 294, 14)) +>mapper : Symbol(mapper, Decl(immutable.ts, 294, 17)) +>value : Symbol(value, Decl(immutable.ts, 294, 26)) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) +>key : Symbol(key, Decl(immutable.ts, 294, 35)) +>iter : Symbol(iter, Decl(immutable.ts, 294, 48)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 294, 14)) ->context : Symbol(context, Decl(immutable.d.ts, 294, 76)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->M : Symbol(M, Decl(immutable.d.ts, 294, 14)) +>M : Symbol(M, Decl(immutable.ts, 294, 14)) +>context : Symbol(context, Decl(immutable.ts, 294, 76)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>M : Symbol(M, Decl(immutable.ts, 294, 14)) filter(predicate: (value: T, index: number, iter: this) => value is F, context?: any): Seq.Indexed; ->filter : Symbol(Indexed.filter, Decl(immutable.d.ts, 294, 108), Decl(immutable.d.ts, 295, 121)) ->F : Symbol(F, Decl(immutable.d.ts, 295, 13)) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 295, 26)) ->value : Symbol(value, Decl(immutable.d.ts, 295, 38)) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) ->index : Symbol(index, Decl(immutable.d.ts, 295, 47)) ->iter : Symbol(iter, Decl(immutable.d.ts, 295, 62)) ->value : Symbol(value, Decl(immutable.d.ts, 295, 38)) ->F : Symbol(F, Decl(immutable.d.ts, 295, 13)) ->context : Symbol(context, Decl(immutable.d.ts, 295, 89)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->F : Symbol(F, Decl(immutable.d.ts, 295, 13)) +>filter : Symbol(Indexed.filter, Decl(immutable.ts, 294, 108), Decl(immutable.ts, 295, 121)) +>F : Symbol(F, Decl(immutable.ts, 295, 13)) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) +>predicate : Symbol(predicate, Decl(immutable.ts, 295, 26)) +>value : Symbol(value, Decl(immutable.ts, 295, 38)) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) +>index : Symbol(index, Decl(immutable.ts, 295, 47)) +>iter : Symbol(iter, Decl(immutable.ts, 295, 62)) +>value : Symbol(value, Decl(immutable.ts, 295, 38)) +>F : Symbol(F, Decl(immutable.ts, 295, 13)) +>context : Symbol(context, Decl(immutable.ts, 295, 89)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>F : Symbol(F, Decl(immutable.ts, 295, 13)) filter(predicate: (value: T, index: number, iter: this) => any, context?: any): this; ->filter : Symbol(Indexed.filter, Decl(immutable.d.ts, 294, 108), Decl(immutable.d.ts, 295, 121)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 296, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 296, 25)) ->T : Symbol(T, Decl(immutable.d.ts, 288, 29)) ->index : Symbol(index, Decl(immutable.d.ts, 296, 34)) ->iter : Symbol(iter, Decl(immutable.d.ts, 296, 49)) ->context : Symbol(context, Decl(immutable.d.ts, 296, 69)) +>filter : Symbol(Indexed.filter, Decl(immutable.ts, 294, 108), Decl(immutable.ts, 295, 121)) +>predicate : Symbol(predicate, Decl(immutable.ts, 296, 13)) +>value : Symbol(value, Decl(immutable.ts, 296, 25)) +>T : Symbol(T, Decl(immutable.ts, 288, 29)) +>index : Symbol(index, Decl(immutable.ts, 296, 34)) +>iter : Symbol(iter, Decl(immutable.ts, 296, 49)) +>context : Symbol(context, Decl(immutable.ts, 296, 69)) } export module Set { ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) function of(...values: Array): Seq.Set; ->of : Symbol(of, Decl(immutable.d.ts, 298, 23)) ->T : Symbol(T, Decl(immutable.d.ts, 299, 18)) ->values : Symbol(values, Decl(immutable.d.ts, 299, 21)) +>of : Symbol(of, Decl(immutable.ts, 298, 23)) +>T : Symbol(T, Decl(immutable.ts, 299, 18)) +>values : Symbol(values, Decl(immutable.ts, 299, 21)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 299, 18)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 299, 18)) +>T : Symbol(T, Decl(immutable.ts, 299, 18)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>T : Symbol(T, Decl(immutable.ts, 299, 18)) } export function Set(): Seq.Set; ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) export function Set(): Seq.Set; ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 302, 24)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 302, 24)) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>T : Symbol(T, Decl(immutable.ts, 302, 24)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>T : Symbol(T, Decl(immutable.ts, 302, 24)) export function Set(collection: Iterable): Seq.Set; ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 303, 24)) ->collection : Symbol(collection, Decl(immutable.d.ts, 303, 27)) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>T : Symbol(T, Decl(immutable.ts, 303, 24)) +>collection : Symbol(collection, Decl(immutable.ts, 303, 27)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 303, 24)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 303, 24)) +>T : Symbol(T, Decl(immutable.ts, 303, 24)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>T : Symbol(T, Decl(immutable.ts, 303, 24)) export interface Set extends Seq, Collection.Set { ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) ->Collection.Set : Symbol(Collection.Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Set : Symbol(Collection.Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) +>Collection.Set : Symbol(Collection.Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Set : Symbol(Collection.Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) toJS(): Array; ->toJS : Symbol(Set.toJS, Decl(immutable.d.ts, 304, 70)) +>toJS : Symbol(Set.toJS, Decl(immutable.ts, 304, 70)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) toJSON(): Array; ->toJSON : Symbol(Set.toJSON, Decl(immutable.d.ts, 305, 25)) +>toJSON : Symbol(Set.toJSON, Decl(immutable.ts, 305, 25)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) toSeq(): this; ->toSeq : Symbol(Set.toSeq, Decl(immutable.d.ts, 306, 25)) +>toSeq : Symbol(Set.toSeq, Decl(immutable.ts, 306, 25)) concat(...valuesOrCollections: Array | C>): Seq.Set; ->concat : Symbol(Set.concat, Decl(immutable.d.ts, 307, 20)) ->C : Symbol(C, Decl(immutable.d.ts, 308, 13)) ->valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.d.ts, 308, 16)) +>concat : Symbol(Set.concat, Decl(immutable.ts, 307, 20)) +>C : Symbol(C, Decl(immutable.ts, 308, 13)) +>valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.ts, 308, 16)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->C : Symbol(C, Decl(immutable.d.ts, 308, 13)) ->C : Symbol(C, Decl(immutable.d.ts, 308, 13)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) ->C : Symbol(C, Decl(immutable.d.ts, 308, 13)) +>C : Symbol(C, Decl(immutable.ts, 308, 13)) +>C : Symbol(C, Decl(immutable.ts, 308, 13)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) +>C : Symbol(C, Decl(immutable.ts, 308, 13)) map(mapper: (value: T, key: never, iter: this) => M, context?: any): Seq.Set; ->map : Symbol(Set.map, Decl(immutable.d.ts, 308, 80)) ->M : Symbol(M, Decl(immutable.d.ts, 309, 10)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 309, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 309, 22)) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 309, 31)) ->iter : Symbol(iter, Decl(immutable.d.ts, 309, 43)) ->M : Symbol(M, Decl(immutable.d.ts, 309, 10)) ->context : Symbol(context, Decl(immutable.d.ts, 309, 61)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->M : Symbol(M, Decl(immutable.d.ts, 309, 10)) +>map : Symbol(Set.map, Decl(immutable.ts, 308, 80)) +>M : Symbol(M, Decl(immutable.ts, 309, 10)) +>mapper : Symbol(mapper, Decl(immutable.ts, 309, 13)) +>value : Symbol(value, Decl(immutable.ts, 309, 22)) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) +>key : Symbol(key, Decl(immutable.ts, 309, 31)) +>iter : Symbol(iter, Decl(immutable.ts, 309, 43)) +>M : Symbol(M, Decl(immutable.ts, 309, 10)) +>context : Symbol(context, Decl(immutable.ts, 309, 61)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>M : Symbol(M, Decl(immutable.ts, 309, 10)) flatMap(mapper: (value: T, key: never, iter: this) => Iterable, context?: any): Seq.Set; ->flatMap : Symbol(Set.flatMap, Decl(immutable.d.ts, 309, 89)) ->M : Symbol(M, Decl(immutable.d.ts, 310, 14)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 310, 17)) ->value : Symbol(value, Decl(immutable.d.ts, 310, 26)) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 310, 35)) ->iter : Symbol(iter, Decl(immutable.d.ts, 310, 47)) +>flatMap : Symbol(Set.flatMap, Decl(immutable.ts, 309, 89)) +>M : Symbol(M, Decl(immutable.ts, 310, 14)) +>mapper : Symbol(mapper, Decl(immutable.ts, 310, 17)) +>value : Symbol(value, Decl(immutable.ts, 310, 26)) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) +>key : Symbol(key, Decl(immutable.ts, 310, 35)) +>iter : Symbol(iter, Decl(immutable.ts, 310, 47)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 310, 14)) ->context : Symbol(context, Decl(immutable.d.ts, 310, 75)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->M : Symbol(M, Decl(immutable.d.ts, 310, 14)) +>M : Symbol(M, Decl(immutable.ts, 310, 14)) +>context : Symbol(context, Decl(immutable.ts, 310, 75)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>M : Symbol(M, Decl(immutable.ts, 310, 14)) filter(predicate: (value: T, key: never, iter: this) => value is F, context?: any): Seq.Set; ->filter : Symbol(Set.filter, Decl(immutable.d.ts, 310, 103), Decl(immutable.d.ts, 311, 114)) ->F : Symbol(F, Decl(immutable.d.ts, 311, 13)) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 311, 26)) ->value : Symbol(value, Decl(immutable.d.ts, 311, 38)) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 311, 47)) ->iter : Symbol(iter, Decl(immutable.d.ts, 311, 59)) ->value : Symbol(value, Decl(immutable.d.ts, 311, 38)) ->F : Symbol(F, Decl(immutable.d.ts, 311, 13)) ->context : Symbol(context, Decl(immutable.d.ts, 311, 86)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->F : Symbol(F, Decl(immutable.d.ts, 311, 13)) +>filter : Symbol(Set.filter, Decl(immutable.ts, 310, 103), Decl(immutable.ts, 311, 114)) +>F : Symbol(F, Decl(immutable.ts, 311, 13)) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) +>predicate : Symbol(predicate, Decl(immutable.ts, 311, 26)) +>value : Symbol(value, Decl(immutable.ts, 311, 38)) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) +>key : Symbol(key, Decl(immutable.ts, 311, 47)) +>iter : Symbol(iter, Decl(immutable.ts, 311, 59)) +>value : Symbol(value, Decl(immutable.ts, 311, 38)) +>F : Symbol(F, Decl(immutable.ts, 311, 13)) +>context : Symbol(context, Decl(immutable.ts, 311, 86)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>F : Symbol(F, Decl(immutable.ts, 311, 13)) filter(predicate: (value: T, key: never, iter: this) => any, context?: any): this; ->filter : Symbol(Set.filter, Decl(immutable.d.ts, 310, 103), Decl(immutable.d.ts, 311, 114)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 312, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 312, 25)) ->T : Symbol(T, Decl(immutable.d.ts, 304, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 312, 34)) ->iter : Symbol(iter, Decl(immutable.d.ts, 312, 46)) ->context : Symbol(context, Decl(immutable.d.ts, 312, 66)) +>filter : Symbol(Set.filter, Decl(immutable.ts, 310, 103), Decl(immutable.ts, 311, 114)) +>predicate : Symbol(predicate, Decl(immutable.ts, 312, 13)) +>value : Symbol(value, Decl(immutable.ts, 312, 25)) +>T : Symbol(T, Decl(immutable.ts, 304, 25)) +>key : Symbol(key, Decl(immutable.ts, 312, 34)) +>iter : Symbol(iter, Decl(immutable.ts, 312, 46)) +>context : Symbol(context, Decl(immutable.ts, 312, 66)) } } export function Seq>(seq: S): S; ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->S : Symbol(S, Decl(immutable.d.ts, 315, 22)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->seq : Symbol(seq, Decl(immutable.d.ts, 315, 47)) ->S : Symbol(S, Decl(immutable.d.ts, 315, 22)) ->S : Symbol(S, Decl(immutable.d.ts, 315, 22)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>S : Symbol(S, Decl(immutable.ts, 315, 22)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>seq : Symbol(seq, Decl(immutable.ts, 315, 47)) +>S : Symbol(S, Decl(immutable.ts, 315, 22)) +>S : Symbol(S, Decl(immutable.ts, 315, 22)) export function Seq(collection: Collection.Keyed): Seq.Keyed; ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->K : Symbol(K, Decl(immutable.d.ts, 316, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 316, 24)) ->collection : Symbol(collection, Decl(immutable.d.ts, 316, 28)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Collection.Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 316, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 316, 24)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Seq.Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 316, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 316, 24)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>K : Symbol(K, Decl(immutable.ts, 316, 22)) +>V : Symbol(V, Decl(immutable.ts, 316, 24)) +>collection : Symbol(collection, Decl(immutable.ts, 316, 28)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Collection.Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 316, 22)) +>V : Symbol(V, Decl(immutable.ts, 316, 24)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Seq.Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 316, 22)) +>V : Symbol(V, Decl(immutable.ts, 316, 24)) export function Seq(collection: Collection.Indexed): Seq.Indexed; ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->T : Symbol(T, Decl(immutable.d.ts, 317, 22)) ->collection : Symbol(collection, Decl(immutable.d.ts, 317, 25)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 317, 22)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Seq.Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 317, 22)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>T : Symbol(T, Decl(immutable.ts, 317, 22)) +>collection : Symbol(collection, Decl(immutable.ts, 317, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 317, 22)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Seq.Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 317, 22)) export function Seq(collection: Collection.Set): Seq.Set; ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->T : Symbol(T, Decl(immutable.d.ts, 318, 22)) ->collection : Symbol(collection, Decl(immutable.d.ts, 318, 25)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Set : Symbol(Collection.Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->T : Symbol(T, Decl(immutable.d.ts, 318, 22)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Seq.Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 318, 22)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>T : Symbol(T, Decl(immutable.ts, 318, 22)) +>collection : Symbol(collection, Decl(immutable.ts, 318, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Set : Symbol(Collection.Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>T : Symbol(T, Decl(immutable.ts, 318, 22)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Seq.Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>T : Symbol(T, Decl(immutable.ts, 318, 22)) export function Seq(collection: Iterable): Seq.Indexed; ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->T : Symbol(T, Decl(immutable.d.ts, 319, 22)) ->collection : Symbol(collection, Decl(immutable.d.ts, 319, 25)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>T : Symbol(T, Decl(immutable.ts, 319, 22)) +>collection : Symbol(collection, Decl(immutable.ts, 319, 25)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 319, 22)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Seq.Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 319, 22)) +>T : Symbol(T, Decl(immutable.ts, 319, 22)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Seq.Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 319, 22)) export function Seq(obj: {[key: string]: V}): Seq.Keyed; ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->V : Symbol(V, Decl(immutable.d.ts, 320, 22)) ->obj : Symbol(obj, Decl(immutable.d.ts, 320, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 320, 32)) ->V : Symbol(V, Decl(immutable.d.ts, 320, 22)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Seq.Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->V : Symbol(V, Decl(immutable.d.ts, 320, 22)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>V : Symbol(V, Decl(immutable.ts, 320, 22)) +>obj : Symbol(obj, Decl(immutable.ts, 320, 25)) +>key : Symbol(key, Decl(immutable.ts, 320, 32)) +>V : Symbol(V, Decl(immutable.ts, 320, 22)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Seq.Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>V : Symbol(V, Decl(immutable.ts, 320, 22)) export function Seq(): Seq; ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) export interface Seq extends Collection { ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->K : Symbol(K, Decl(immutable.d.ts, 322, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 322, 25)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 322, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 322, 25)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>K : Symbol(K, Decl(immutable.ts, 322, 23)) +>V : Symbol(V, Decl(immutable.ts, 322, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 322, 23)) +>V : Symbol(V, Decl(immutable.ts, 322, 25)) readonly size: number | undefined; ->size : Symbol(Seq.size, Decl(immutable.d.ts, 322, 55)) +>size : Symbol(Seq.size, Decl(immutable.ts, 322, 55)) // Force evaluation cacheResult(): this; ->cacheResult : Symbol(Seq.cacheResult, Decl(immutable.d.ts, 323, 38)) +>cacheResult : Symbol(Seq.cacheResult, Decl(immutable.ts, 323, 38)) // Sequence algorithms map(mapper: (value: V, key: K, iter: this) => M, context?: any): Seq; ->map : Symbol(Seq.map, Decl(immutable.d.ts, 325, 24)) ->M : Symbol(M, Decl(immutable.d.ts, 327, 8)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 327, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 327, 20)) ->V : Symbol(V, Decl(immutable.d.ts, 322, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 327, 29)) ->K : Symbol(K, Decl(immutable.d.ts, 322, 23)) ->iter : Symbol(iter, Decl(immutable.d.ts, 327, 37)) ->M : Symbol(M, Decl(immutable.d.ts, 327, 8)) ->context : Symbol(context, Decl(immutable.d.ts, 327, 55)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->K : Symbol(K, Decl(immutable.d.ts, 322, 23)) ->M : Symbol(M, Decl(immutable.d.ts, 327, 8)) +>map : Symbol(Seq.map, Decl(immutable.ts, 325, 24)) +>M : Symbol(M, Decl(immutable.ts, 327, 8)) +>mapper : Symbol(mapper, Decl(immutable.ts, 327, 11)) +>value : Symbol(value, Decl(immutable.ts, 327, 20)) +>V : Symbol(V, Decl(immutable.ts, 322, 25)) +>key : Symbol(key, Decl(immutable.ts, 327, 29)) +>K : Symbol(K, Decl(immutable.ts, 322, 23)) +>iter : Symbol(iter, Decl(immutable.ts, 327, 37)) +>M : Symbol(M, Decl(immutable.ts, 327, 8)) +>context : Symbol(context, Decl(immutable.ts, 327, 55)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>K : Symbol(K, Decl(immutable.ts, 322, 23)) +>M : Symbol(M, Decl(immutable.ts, 327, 8)) flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Seq; ->flatMap : Symbol(Seq.flatMap, Decl(immutable.d.ts, 327, 82)) ->M : Symbol(M, Decl(immutable.d.ts, 328, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 328, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 328, 24)) ->V : Symbol(V, Decl(immutable.d.ts, 322, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 328, 33)) ->K : Symbol(K, Decl(immutable.d.ts, 322, 23)) ->iter : Symbol(iter, Decl(immutable.d.ts, 328, 41)) +>flatMap : Symbol(Seq.flatMap, Decl(immutable.ts, 327, 82)) +>M : Symbol(M, Decl(immutable.ts, 328, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 328, 15)) +>value : Symbol(value, Decl(immutable.ts, 328, 24)) +>V : Symbol(V, Decl(immutable.ts, 322, 25)) +>key : Symbol(key, Decl(immutable.ts, 328, 33)) +>K : Symbol(K, Decl(immutable.ts, 322, 23)) +>iter : Symbol(iter, Decl(immutable.ts, 328, 41)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 328, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 328, 69)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->K : Symbol(K, Decl(immutable.d.ts, 322, 23)) ->M : Symbol(M, Decl(immutable.d.ts, 328, 12)) +>M : Symbol(M, Decl(immutable.ts, 328, 12)) +>context : Symbol(context, Decl(immutable.ts, 328, 69)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>K : Symbol(K, Decl(immutable.ts, 322, 23)) +>M : Symbol(M, Decl(immutable.ts, 328, 12)) filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Seq; ->filter : Symbol(Seq.filter, Decl(immutable.d.ts, 328, 96), Decl(immutable.d.ts, 329, 107)) ->F : Symbol(F, Decl(immutable.d.ts, 329, 11)) ->V : Symbol(V, Decl(immutable.d.ts, 322, 25)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 329, 24)) ->value : Symbol(value, Decl(immutable.d.ts, 329, 36)) ->V : Symbol(V, Decl(immutable.d.ts, 322, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 329, 45)) ->K : Symbol(K, Decl(immutable.d.ts, 322, 23)) ->iter : Symbol(iter, Decl(immutable.d.ts, 329, 53)) ->value : Symbol(value, Decl(immutable.d.ts, 329, 36)) ->F : Symbol(F, Decl(immutable.d.ts, 329, 11)) ->context : Symbol(context, Decl(immutable.d.ts, 329, 80)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->K : Symbol(K, Decl(immutable.d.ts, 322, 23)) ->F : Symbol(F, Decl(immutable.d.ts, 329, 11)) +>filter : Symbol(Seq.filter, Decl(immutable.ts, 328, 96), Decl(immutable.ts, 329, 107)) +>F : Symbol(F, Decl(immutable.ts, 329, 11)) +>V : Symbol(V, Decl(immutable.ts, 322, 25)) +>predicate : Symbol(predicate, Decl(immutable.ts, 329, 24)) +>value : Symbol(value, Decl(immutable.ts, 329, 36)) +>V : Symbol(V, Decl(immutable.ts, 322, 25)) +>key : Symbol(key, Decl(immutable.ts, 329, 45)) +>K : Symbol(K, Decl(immutable.ts, 322, 23)) +>iter : Symbol(iter, Decl(immutable.ts, 329, 53)) +>value : Symbol(value, Decl(immutable.ts, 329, 36)) +>F : Symbol(F, Decl(immutable.ts, 329, 11)) +>context : Symbol(context, Decl(immutable.ts, 329, 80)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>K : Symbol(K, Decl(immutable.ts, 322, 23)) +>F : Symbol(F, Decl(immutable.ts, 329, 11)) filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; ->filter : Symbol(Seq.filter, Decl(immutable.d.ts, 328, 96), Decl(immutable.d.ts, 329, 107)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 330, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 330, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 322, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 330, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 322, 23)) ->iter : Symbol(iter, Decl(immutable.d.ts, 330, 40)) ->context : Symbol(context, Decl(immutable.d.ts, 330, 60)) +>filter : Symbol(Seq.filter, Decl(immutable.ts, 328, 96), Decl(immutable.ts, 329, 107)) +>predicate : Symbol(predicate, Decl(immutable.ts, 330, 11)) +>value : Symbol(value, Decl(immutable.ts, 330, 23)) +>V : Symbol(V, Decl(immutable.ts, 322, 25)) +>key : Symbol(key, Decl(immutable.ts, 330, 32)) +>K : Symbol(K, Decl(immutable.ts, 322, 23)) +>iter : Symbol(iter, Decl(immutable.ts, 330, 40)) +>context : Symbol(context, Decl(immutable.ts, 330, 60)) } export module Collection { ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) function isKeyed(maybeKeyed: any): maybeKeyed is Collection.Keyed; ->isKeyed : Symbol(isKeyed, Decl(immutable.d.ts, 332, 28)) ->maybeKeyed : Symbol(maybeKeyed, Decl(immutable.d.ts, 333, 21)) ->maybeKeyed : Symbol(maybeKeyed, Decl(immutable.d.ts, 333, 21)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) +>isKeyed : Symbol(isKeyed, Decl(immutable.ts, 332, 28)) +>maybeKeyed : Symbol(maybeKeyed, Decl(immutable.ts, 333, 21)) +>maybeKeyed : Symbol(maybeKeyed, Decl(immutable.ts, 333, 21)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) function isIndexed(maybeIndexed: any): maybeIndexed is Collection.Indexed; ->isIndexed : Symbol(isIndexed, Decl(immutable.d.ts, 333, 80)) ->maybeIndexed : Symbol(maybeIndexed, Decl(immutable.d.ts, 334, 23)) ->maybeIndexed : Symbol(maybeIndexed, Decl(immutable.d.ts, 334, 23)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) +>isIndexed : Symbol(isIndexed, Decl(immutable.ts, 333, 80)) +>maybeIndexed : Symbol(maybeIndexed, Decl(immutable.ts, 334, 23)) +>maybeIndexed : Symbol(maybeIndexed, Decl(immutable.ts, 334, 23)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) function isAssociative(maybeAssociative: any): maybeAssociative is Collection.Keyed | Collection.Indexed; ->isAssociative : Symbol(isAssociative, Decl(immutable.d.ts, 334, 83)) ->maybeAssociative : Symbol(maybeAssociative, Decl(immutable.d.ts, 335, 27)) ->maybeAssociative : Symbol(maybeAssociative, Decl(immutable.d.ts, 335, 27)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) +>isAssociative : Symbol(isAssociative, Decl(immutable.ts, 334, 83)) +>maybeAssociative : Symbol(maybeAssociative, Decl(immutable.ts, 335, 27)) +>maybeAssociative : Symbol(maybeAssociative, Decl(immutable.ts, 335, 27)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) function isOrdered(maybeOrdered: any): boolean; ->isOrdered : Symbol(isOrdered, Decl(immutable.d.ts, 335, 124)) ->maybeOrdered : Symbol(maybeOrdered, Decl(immutable.d.ts, 336, 23)) +>isOrdered : Symbol(isOrdered, Decl(immutable.ts, 335, 124)) +>maybeOrdered : Symbol(maybeOrdered, Decl(immutable.ts, 336, 23)) export module Keyed {} ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) export function Keyed(collection: Iterable<[K, V]>): Collection.Keyed; ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 338, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 338, 28)) ->collection : Symbol(collection, Decl(immutable.d.ts, 338, 32)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 338, 26)) +>V : Symbol(V, Decl(immutable.ts, 338, 28)) +>collection : Symbol(collection, Decl(immutable.ts, 338, 32)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->K : Symbol(K, Decl(immutable.d.ts, 338, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 338, 28)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 338, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 338, 28)) +>K : Symbol(K, Decl(immutable.ts, 338, 26)) +>V : Symbol(V, Decl(immutable.ts, 338, 28)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 338, 26)) +>V : Symbol(V, Decl(immutable.ts, 338, 28)) export function Keyed(obj: {[key: string]: V}): Collection.Keyed; ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->V : Symbol(V, Decl(immutable.d.ts, 339, 26)) ->obj : Symbol(obj, Decl(immutable.d.ts, 339, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 339, 36)) ->V : Symbol(V, Decl(immutable.d.ts, 339, 26)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->V : Symbol(V, Decl(immutable.d.ts, 339, 26)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>V : Symbol(V, Decl(immutable.ts, 339, 26)) +>obj : Symbol(obj, Decl(immutable.ts, 339, 29)) +>key : Symbol(key, Decl(immutable.ts, 339, 36)) +>V : Symbol(V, Decl(immutable.ts, 339, 26)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>V : Symbol(V, Decl(immutable.ts, 339, 26)) export interface Keyed extends Collection { ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) toJS(): Object; ->toJS : Symbol(Keyed.toJS, Decl(immutable.d.ts, 340, 59)) +>toJS : Symbol(Keyed.toJS, Decl(immutable.ts, 340, 59)) >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) toJSON(): { [key: string]: V }; ->toJSON : Symbol(Keyed.toJSON, Decl(immutable.d.ts, 341, 21)) ->key : Symbol(key, Decl(immutable.d.ts, 342, 19)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) +>toJSON : Symbol(Keyed.toJSON, Decl(immutable.ts, 341, 21)) +>key : Symbol(key, Decl(immutable.ts, 342, 19)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) toSeq(): Seq.Keyed; ->toSeq : Symbol(Keyed.toSeq, Decl(immutable.d.ts, 342, 37)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Seq.Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) +>toSeq : Symbol(Keyed.toSeq, Decl(immutable.ts, 342, 37)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Seq.Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) // Sequence functions flip(): this; ->flip : Symbol(Keyed.flip, Decl(immutable.d.ts, 343, 31)) +>flip : Symbol(Keyed.flip, Decl(immutable.ts, 343, 31)) concat(...collections: Array>): Collection.Keyed; ->concat : Symbol(Keyed.concat, Decl(immutable.d.ts, 345, 19), Decl(immutable.d.ts, 346, 98)) ->KC : Symbol(KC, Decl(immutable.d.ts, 346, 13)) ->VC : Symbol(VC, Decl(immutable.d.ts, 346, 16)) ->collections : Symbol(collections, Decl(immutable.d.ts, 346, 21)) +>concat : Symbol(Keyed.concat, Decl(immutable.ts, 345, 19), Decl(immutable.ts, 346, 98)) +>KC : Symbol(KC, Decl(immutable.ts, 346, 13)) +>VC : Symbol(VC, Decl(immutable.ts, 346, 16)) +>collections : Symbol(collections, Decl(immutable.ts, 346, 21)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->KC : Symbol(KC, Decl(immutable.d.ts, 346, 13)) ->VC : Symbol(VC, Decl(immutable.d.ts, 346, 16)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->KC : Symbol(KC, Decl(immutable.d.ts, 346, 13)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->VC : Symbol(VC, Decl(immutable.d.ts, 346, 16)) +>KC : Symbol(KC, Decl(immutable.ts, 346, 13)) +>VC : Symbol(VC, Decl(immutable.ts, 346, 16)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>KC : Symbol(KC, Decl(immutable.ts, 346, 13)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>VC : Symbol(VC, Decl(immutable.ts, 346, 16)) concat(...collections: Array<{[key: string]: C}>): Collection.Keyed; ->concat : Symbol(Keyed.concat, Decl(immutable.d.ts, 345, 19), Decl(immutable.d.ts, 346, 98)) ->C : Symbol(C, Decl(immutable.d.ts, 347, 13)) ->collections : Symbol(collections, Decl(immutable.d.ts, 347, 16)) +>concat : Symbol(Keyed.concat, Decl(immutable.ts, 345, 19), Decl(immutable.ts, 346, 98)) +>C : Symbol(C, Decl(immutable.ts, 347, 13)) +>collections : Symbol(collections, Decl(immutable.ts, 347, 16)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->key : Symbol(key, Decl(immutable.d.ts, 347, 40)) ->C : Symbol(C, Decl(immutable.d.ts, 347, 13)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->C : Symbol(C, Decl(immutable.d.ts, 347, 13)) +>key : Symbol(key, Decl(immutable.ts, 347, 40)) +>C : Symbol(C, Decl(immutable.ts, 347, 13)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>C : Symbol(C, Decl(immutable.ts, 347, 13)) map(mapper: (value: V, key: K, iter: this) => M, context?: any): Collection.Keyed; ->map : Symbol(Keyed.map, Decl(immutable.d.ts, 347, 96)) ->M : Symbol(M, Decl(immutable.d.ts, 348, 10)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 348, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 348, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 348, 31)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->iter : Symbol(iter, Decl(immutable.d.ts, 348, 39)) ->M : Symbol(M, Decl(immutable.d.ts, 348, 10)) ->context : Symbol(context, Decl(immutable.d.ts, 348, 57)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->M : Symbol(M, Decl(immutable.d.ts, 348, 10)) +>map : Symbol(Keyed.map, Decl(immutable.ts, 347, 96)) +>M : Symbol(M, Decl(immutable.ts, 348, 10)) +>mapper : Symbol(mapper, Decl(immutable.ts, 348, 13)) +>value : Symbol(value, Decl(immutable.ts, 348, 22)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>key : Symbol(key, Decl(immutable.ts, 348, 31)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>iter : Symbol(iter, Decl(immutable.ts, 348, 39)) +>M : Symbol(M, Decl(immutable.ts, 348, 10)) +>context : Symbol(context, Decl(immutable.ts, 348, 57)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>M : Symbol(M, Decl(immutable.ts, 348, 10)) mapKeys(mapper: (key: K, value: V, iter: this) => M, context?: any): Collection.Keyed; ->mapKeys : Symbol(Keyed.mapKeys, Decl(immutable.d.ts, 348, 97)) ->M : Symbol(M, Decl(immutable.d.ts, 349, 14)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 349, 17)) ->key : Symbol(key, Decl(immutable.d.ts, 349, 26)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->value : Symbol(value, Decl(immutable.d.ts, 349, 33)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->iter : Symbol(iter, Decl(immutable.d.ts, 349, 43)) ->M : Symbol(M, Decl(immutable.d.ts, 349, 14)) ->context : Symbol(context, Decl(immutable.d.ts, 349, 61)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->M : Symbol(M, Decl(immutable.d.ts, 349, 14)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) +>mapKeys : Symbol(Keyed.mapKeys, Decl(immutable.ts, 348, 97)) +>M : Symbol(M, Decl(immutable.ts, 349, 14)) +>mapper : Symbol(mapper, Decl(immutable.ts, 349, 17)) +>key : Symbol(key, Decl(immutable.ts, 349, 26)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>value : Symbol(value, Decl(immutable.ts, 349, 33)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>iter : Symbol(iter, Decl(immutable.ts, 349, 43)) +>M : Symbol(M, Decl(immutable.ts, 349, 14)) +>context : Symbol(context, Decl(immutable.ts, 349, 61)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>M : Symbol(M, Decl(immutable.ts, 349, 14)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) mapEntries(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM], context?: any): Collection.Keyed; ->mapEntries : Symbol(Keyed.mapEntries, Decl(immutable.d.ts, 349, 101)) ->KM : Symbol(KM, Decl(immutable.d.ts, 350, 17)) ->VM : Symbol(VM, Decl(immutable.d.ts, 350, 20)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 350, 25)) ->entry : Symbol(entry, Decl(immutable.d.ts, 350, 34)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->index : Symbol(index, Decl(immutable.d.ts, 350, 48)) ->iter : Symbol(iter, Decl(immutable.d.ts, 350, 63)) ->KM : Symbol(KM, Decl(immutable.d.ts, 350, 17)) ->VM : Symbol(VM, Decl(immutable.d.ts, 350, 20)) ->context : Symbol(context, Decl(immutable.d.ts, 350, 88)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->KM : Symbol(KM, Decl(immutable.d.ts, 350, 17)) ->VM : Symbol(VM, Decl(immutable.d.ts, 350, 20)) +>mapEntries : Symbol(Keyed.mapEntries, Decl(immutable.ts, 349, 101)) +>KM : Symbol(KM, Decl(immutable.ts, 350, 17)) +>VM : Symbol(VM, Decl(immutable.ts, 350, 20)) +>mapper : Symbol(mapper, Decl(immutable.ts, 350, 25)) +>entry : Symbol(entry, Decl(immutable.ts, 350, 34)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>index : Symbol(index, Decl(immutable.ts, 350, 48)) +>iter : Symbol(iter, Decl(immutable.ts, 350, 63)) +>KM : Symbol(KM, Decl(immutable.ts, 350, 17)) +>VM : Symbol(VM, Decl(immutable.ts, 350, 20)) +>context : Symbol(context, Decl(immutable.ts, 350, 88)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>KM : Symbol(KM, Decl(immutable.ts, 350, 17)) +>VM : Symbol(VM, Decl(immutable.ts, 350, 20)) flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Collection.Keyed; ->flatMap : Symbol(Keyed.flatMap, Decl(immutable.d.ts, 350, 130)) ->M : Symbol(M, Decl(immutable.d.ts, 351, 14)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 351, 17)) ->value : Symbol(value, Decl(immutable.d.ts, 351, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 351, 35)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->iter : Symbol(iter, Decl(immutable.d.ts, 351, 43)) +>flatMap : Symbol(Keyed.flatMap, Decl(immutable.ts, 350, 130)) +>M : Symbol(M, Decl(immutable.ts, 351, 14)) +>mapper : Symbol(mapper, Decl(immutable.ts, 351, 17)) +>value : Symbol(value, Decl(immutable.ts, 351, 26)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>key : Symbol(key, Decl(immutable.ts, 351, 35)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>iter : Symbol(iter, Decl(immutable.ts, 351, 43)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 351, 14)) ->context : Symbol(context, Decl(immutable.d.ts, 351, 71)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) +>M : Symbol(M, Decl(immutable.ts, 351, 14)) +>context : Symbol(context, Decl(immutable.ts, 351, 71)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Collection.Keyed; ->filter : Symbol(Keyed.filter, Decl(immutable.d.ts, 351, 115), Decl(immutable.d.ts, 352, 122)) ->F : Symbol(F, Decl(immutable.d.ts, 352, 13)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 352, 26)) ->value : Symbol(value, Decl(immutable.d.ts, 352, 38)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 352, 47)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->iter : Symbol(iter, Decl(immutable.d.ts, 352, 55)) ->value : Symbol(value, Decl(immutable.d.ts, 352, 38)) ->F : Symbol(F, Decl(immutable.d.ts, 352, 13)) ->context : Symbol(context, Decl(immutable.d.ts, 352, 82)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->F : Symbol(F, Decl(immutable.d.ts, 352, 13)) +>filter : Symbol(Keyed.filter, Decl(immutable.ts, 351, 115), Decl(immutable.ts, 352, 122)) +>F : Symbol(F, Decl(immutable.ts, 352, 13)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>predicate : Symbol(predicate, Decl(immutable.ts, 352, 26)) +>value : Symbol(value, Decl(immutable.ts, 352, 38)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>key : Symbol(key, Decl(immutable.ts, 352, 47)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>iter : Symbol(iter, Decl(immutable.ts, 352, 55)) +>value : Symbol(value, Decl(immutable.ts, 352, 38)) +>F : Symbol(F, Decl(immutable.ts, 352, 13)) +>context : Symbol(context, Decl(immutable.ts, 352, 82)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>F : Symbol(F, Decl(immutable.ts, 352, 13)) filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; ->filter : Symbol(Keyed.filter, Decl(immutable.d.ts, 351, 115), Decl(immutable.d.ts, 352, 122)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 353, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 353, 25)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 353, 34)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->iter : Symbol(iter, Decl(immutable.d.ts, 353, 42)) ->context : Symbol(context, Decl(immutable.d.ts, 353, 62)) +>filter : Symbol(Keyed.filter, Decl(immutable.ts, 351, 115), Decl(immutable.ts, 352, 122)) +>predicate : Symbol(predicate, Decl(immutable.ts, 353, 13)) +>value : Symbol(value, Decl(immutable.ts, 353, 25)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) +>key : Symbol(key, Decl(immutable.ts, 353, 34)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>iter : Symbol(iter, Decl(immutable.ts, 353, 42)) +>context : Symbol(context, Decl(immutable.ts, 353, 62)) [Symbol.iterator](): IterableIterator<[K, V]>; >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->K : Symbol(K, Decl(immutable.d.ts, 340, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 340, 29)) +>K : Symbol(K, Decl(immutable.ts, 340, 27)) +>V : Symbol(V, Decl(immutable.ts, 340, 29)) } export module Indexed {} ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) export function Indexed(collection: Iterable): Collection.Indexed; ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 357, 28)) ->collection : Symbol(collection, Decl(immutable.d.ts, 357, 31)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 357, 28)) +>collection : Symbol(collection, Decl(immutable.ts, 357, 31)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 357, 28)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 357, 28)) +>T : Symbol(T, Decl(immutable.ts, 357, 28)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 357, 28)) export interface Indexed extends Collection { ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) toJS(): Array; ->toJS : Symbol(Indexed.toJS, Decl(immutable.d.ts, 358, 63)) +>toJS : Symbol(Indexed.toJS, Decl(immutable.ts, 358, 63)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) toJSON(): Array; ->toJSON : Symbol(Indexed.toJSON, Decl(immutable.d.ts, 359, 25)) +>toJSON : Symbol(Indexed.toJSON, Decl(immutable.ts, 359, 25)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) // Reading values get(index: number, notSetValue: NSV): T | NSV; ->get : Symbol(Indexed.get, Decl(immutable.d.ts, 360, 25), Decl(immutable.d.ts, 362, 57)) ->NSV : Symbol(NSV, Decl(immutable.d.ts, 362, 10)) ->index : Symbol(index, Decl(immutable.d.ts, 362, 15)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 362, 29)) ->NSV : Symbol(NSV, Decl(immutable.d.ts, 362, 10)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->NSV : Symbol(NSV, Decl(immutable.d.ts, 362, 10)) +>get : Symbol(Indexed.get, Decl(immutable.ts, 360, 25), Decl(immutable.ts, 362, 57)) +>NSV : Symbol(NSV, Decl(immutable.ts, 362, 10)) +>index : Symbol(index, Decl(immutable.ts, 362, 15)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 362, 29)) +>NSV : Symbol(NSV, Decl(immutable.ts, 362, 10)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>NSV : Symbol(NSV, Decl(immutable.ts, 362, 10)) get(index: number): T | undefined; ->get : Symbol(Indexed.get, Decl(immutable.d.ts, 360, 25), Decl(immutable.d.ts, 362, 57)) ->index : Symbol(index, Decl(immutable.d.ts, 363, 10)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>get : Symbol(Indexed.get, Decl(immutable.ts, 360, 25), Decl(immutable.ts, 362, 57)) +>index : Symbol(index, Decl(immutable.ts, 363, 10)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) // Conversion to Seq toSeq(): Seq.Indexed; ->toSeq : Symbol(Indexed.toSeq, Decl(immutable.d.ts, 363, 40)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Seq.Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>toSeq : Symbol(Indexed.toSeq, Decl(immutable.ts, 363, 40)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Seq.Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) fromEntrySeq(): Seq.Keyed; ->fromEntrySeq : Symbol(Indexed.fromEntrySeq, Decl(immutable.d.ts, 365, 30)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Seq.Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) +>fromEntrySeq : Symbol(Indexed.fromEntrySeq, Decl(immutable.ts, 365, 30)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Seq.Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) // Combination interpose(separator: T): this; ->interpose : Symbol(Indexed.interpose, Decl(immutable.d.ts, 366, 42)) ->separator : Symbol(separator, Decl(immutable.d.ts, 368, 16)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>interpose : Symbol(Indexed.interpose, Decl(immutable.ts, 366, 42)) +>separator : Symbol(separator, Decl(immutable.ts, 368, 16)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) interleave(...collections: Array>): this; ->interleave : Symbol(Indexed.interleave, Decl(immutable.d.ts, 368, 36)) ->collections : Symbol(collections, Decl(immutable.d.ts, 369, 17)) +>interleave : Symbol(Indexed.interleave, Decl(immutable.ts, 368, 36)) +>collections : Symbol(collections, Decl(immutable.ts, 369, 17)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) splice(index: number, removeNum: number, ...values: Array): this; ->splice : Symbol(Indexed.splice, Decl(immutable.d.ts, 369, 66)) ->index : Symbol(index, Decl(immutable.d.ts, 370, 13)) ->removeNum : Symbol(removeNum, Decl(immutable.d.ts, 370, 27)) ->values : Symbol(values, Decl(immutable.d.ts, 370, 46)) +>splice : Symbol(Indexed.splice, Decl(immutable.ts, 369, 66)) +>index : Symbol(index, Decl(immutable.ts, 370, 13)) +>removeNum : Symbol(removeNum, Decl(immutable.ts, 370, 27)) +>values : Symbol(values, Decl(immutable.ts, 370, 46)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) zip(...collections: Array>): Collection.Indexed; ->zip : Symbol(Indexed.zip, Decl(immutable.d.ts, 370, 74)) ->collections : Symbol(collections, Decl(immutable.d.ts, 371, 10)) +>zip : Symbol(Indexed.zip, Decl(immutable.ts, 370, 74)) +>collections : Symbol(collections, Decl(immutable.ts, 371, 10)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) zipWith(zipper: (value: T, otherValue: U) => Z, otherCollection: Collection): Collection.Indexed; ->zipWith : Symbol(Indexed.zipWith, Decl(immutable.d.ts, 371, 80), Decl(immutable.d.ts, 372, 120), Decl(immutable.d.ts, 373, 175)) ->U : Symbol(U, Decl(immutable.d.ts, 372, 14)) ->Z : Symbol(Z, Decl(immutable.d.ts, 372, 16)) ->zipper : Symbol(zipper, Decl(immutable.d.ts, 372, 20)) ->value : Symbol(value, Decl(immutable.d.ts, 372, 29)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->otherValue : Symbol(otherValue, Decl(immutable.d.ts, 372, 38)) ->U : Symbol(U, Decl(immutable.d.ts, 372, 14)) ->Z : Symbol(Z, Decl(immutable.d.ts, 372, 16)) ->otherCollection : Symbol(otherCollection, Decl(immutable.d.ts, 372, 59)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->U : Symbol(U, Decl(immutable.d.ts, 372, 14)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->Z : Symbol(Z, Decl(immutable.d.ts, 372, 16)) +>zipWith : Symbol(Indexed.zipWith, Decl(immutable.ts, 371, 80), Decl(immutable.ts, 372, 120), Decl(immutable.ts, 373, 175)) +>U : Symbol(U, Decl(immutable.ts, 372, 14)) +>Z : Symbol(Z, Decl(immutable.ts, 372, 16)) +>zipper : Symbol(zipper, Decl(immutable.ts, 372, 20)) +>value : Symbol(value, Decl(immutable.ts, 372, 29)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>otherValue : Symbol(otherValue, Decl(immutable.ts, 372, 38)) +>U : Symbol(U, Decl(immutable.ts, 372, 14)) +>Z : Symbol(Z, Decl(immutable.ts, 372, 16)) +>otherCollection : Symbol(otherCollection, Decl(immutable.ts, 372, 59)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>U : Symbol(U, Decl(immutable.ts, 372, 14)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>Z : Symbol(Z, Decl(immutable.ts, 372, 16)) zipWith(zipper: (value: T, otherValue: U, thirdValue: V) => Z, otherCollection: Collection, thirdCollection: Collection): Collection.Indexed; ->zipWith : Symbol(Indexed.zipWith, Decl(immutable.d.ts, 371, 80), Decl(immutable.d.ts, 372, 120), Decl(immutable.d.ts, 373, 175)) ->U : Symbol(U, Decl(immutable.d.ts, 373, 14)) ->V : Symbol(V, Decl(immutable.d.ts, 373, 16)) ->Z : Symbol(Z, Decl(immutable.d.ts, 373, 19)) ->zipper : Symbol(zipper, Decl(immutable.d.ts, 373, 23)) ->value : Symbol(value, Decl(immutable.d.ts, 373, 32)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->otherValue : Symbol(otherValue, Decl(immutable.d.ts, 373, 41)) ->U : Symbol(U, Decl(immutable.d.ts, 373, 14)) ->thirdValue : Symbol(thirdValue, Decl(immutable.d.ts, 373, 56)) ->V : Symbol(V, Decl(immutable.d.ts, 373, 16)) ->Z : Symbol(Z, Decl(immutable.d.ts, 373, 19)) ->otherCollection : Symbol(otherCollection, Decl(immutable.d.ts, 373, 77)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->U : Symbol(U, Decl(immutable.d.ts, 373, 14)) ->thirdCollection : Symbol(thirdCollection, Decl(immutable.d.ts, 373, 114)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->V : Symbol(V, Decl(immutable.d.ts, 373, 16)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->Z : Symbol(Z, Decl(immutable.d.ts, 373, 19)) +>zipWith : Symbol(Indexed.zipWith, Decl(immutable.ts, 371, 80), Decl(immutable.ts, 372, 120), Decl(immutable.ts, 373, 175)) +>U : Symbol(U, Decl(immutable.ts, 373, 14)) +>V : Symbol(V, Decl(immutable.ts, 373, 16)) +>Z : Symbol(Z, Decl(immutable.ts, 373, 19)) +>zipper : Symbol(zipper, Decl(immutable.ts, 373, 23)) +>value : Symbol(value, Decl(immutable.ts, 373, 32)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>otherValue : Symbol(otherValue, Decl(immutable.ts, 373, 41)) +>U : Symbol(U, Decl(immutable.ts, 373, 14)) +>thirdValue : Symbol(thirdValue, Decl(immutable.ts, 373, 56)) +>V : Symbol(V, Decl(immutable.ts, 373, 16)) +>Z : Symbol(Z, Decl(immutable.ts, 373, 19)) +>otherCollection : Symbol(otherCollection, Decl(immutable.ts, 373, 77)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>U : Symbol(U, Decl(immutable.ts, 373, 14)) +>thirdCollection : Symbol(thirdCollection, Decl(immutable.ts, 373, 114)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>V : Symbol(V, Decl(immutable.ts, 373, 16)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>Z : Symbol(Z, Decl(immutable.ts, 373, 19)) zipWith(zipper: (...any: Array) => Z, ...collections: Array>): Collection.Indexed; ->zipWith : Symbol(Indexed.zipWith, Decl(immutable.d.ts, 371, 80), Decl(immutable.d.ts, 372, 120), Decl(immutable.d.ts, 373, 175)) ->Z : Symbol(Z, Decl(immutable.d.ts, 374, 14)) ->zipper : Symbol(zipper, Decl(immutable.d.ts, 374, 17)) ->any : Symbol(any, Decl(immutable.d.ts, 374, 26)) +>zipWith : Symbol(Indexed.zipWith, Decl(immutable.ts, 371, 80), Decl(immutable.ts, 372, 120), Decl(immutable.ts, 373, 175)) +>Z : Symbol(Z, Decl(immutable.ts, 374, 14)) +>zipper : Symbol(zipper, Decl(immutable.ts, 374, 17)) +>any : Symbol(any, Decl(immutable.ts, 374, 26)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Z : Symbol(Z, Decl(immutable.d.ts, 374, 14)) ->collections : Symbol(collections, Decl(immutable.d.ts, 374, 51)) +>Z : Symbol(Z, Decl(immutable.ts, 374, 14)) +>collections : Symbol(collections, Decl(immutable.ts, 374, 51)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->Z : Symbol(Z, Decl(immutable.d.ts, 374, 14)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>Z : Symbol(Z, Decl(immutable.ts, 374, 14)) // Search for value indexOf(searchValue: T): number; ->indexOf : Symbol(Indexed.indexOf, Decl(immutable.d.ts, 374, 120)) ->searchValue : Symbol(searchValue, Decl(immutable.d.ts, 376, 14)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>indexOf : Symbol(Indexed.indexOf, Decl(immutable.ts, 374, 120)) +>searchValue : Symbol(searchValue, Decl(immutable.ts, 376, 14)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) lastIndexOf(searchValue: T): number; ->lastIndexOf : Symbol(Indexed.lastIndexOf, Decl(immutable.d.ts, 376, 38)) ->searchValue : Symbol(searchValue, Decl(immutable.d.ts, 377, 18)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>lastIndexOf : Symbol(Indexed.lastIndexOf, Decl(immutable.ts, 376, 38)) +>searchValue : Symbol(searchValue, Decl(immutable.ts, 377, 18)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) findIndex(predicate: (value: T, index: number, iter: this) => boolean, context?: any): number; ->findIndex : Symbol(Indexed.findIndex, Decl(immutable.d.ts, 377, 42)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 378, 16)) ->value : Symbol(value, Decl(immutable.d.ts, 378, 28)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->index : Symbol(index, Decl(immutable.d.ts, 378, 37)) ->iter : Symbol(iter, Decl(immutable.d.ts, 378, 52)) ->context : Symbol(context, Decl(immutable.d.ts, 378, 76)) +>findIndex : Symbol(Indexed.findIndex, Decl(immutable.ts, 377, 42)) +>predicate : Symbol(predicate, Decl(immutable.ts, 378, 16)) +>value : Symbol(value, Decl(immutable.ts, 378, 28)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>index : Symbol(index, Decl(immutable.ts, 378, 37)) +>iter : Symbol(iter, Decl(immutable.ts, 378, 52)) +>context : Symbol(context, Decl(immutable.ts, 378, 76)) findLastIndex(predicate: (value: T, index: number, iter: this) => boolean, context?: any): number; ->findLastIndex : Symbol(Indexed.findLastIndex, Decl(immutable.d.ts, 378, 100)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 379, 20)) ->value : Symbol(value, Decl(immutable.d.ts, 379, 32)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->index : Symbol(index, Decl(immutable.d.ts, 379, 41)) ->iter : Symbol(iter, Decl(immutable.d.ts, 379, 56)) ->context : Symbol(context, Decl(immutable.d.ts, 379, 80)) +>findLastIndex : Symbol(Indexed.findLastIndex, Decl(immutable.ts, 378, 100)) +>predicate : Symbol(predicate, Decl(immutable.ts, 379, 20)) +>value : Symbol(value, Decl(immutable.ts, 379, 32)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>index : Symbol(index, Decl(immutable.ts, 379, 41)) +>iter : Symbol(iter, Decl(immutable.ts, 379, 56)) +>context : Symbol(context, Decl(immutable.ts, 379, 80)) // Sequence algorithms concat(...valuesOrCollections: Array | C>): Collection.Indexed; ->concat : Symbol(Indexed.concat, Decl(immutable.d.ts, 379, 104)) ->C : Symbol(C, Decl(immutable.d.ts, 381, 13)) ->valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.d.ts, 381, 16)) +>concat : Symbol(Indexed.concat, Decl(immutable.ts, 379, 104)) +>C : Symbol(C, Decl(immutable.ts, 381, 13)) +>valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.ts, 381, 16)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->C : Symbol(C, Decl(immutable.d.ts, 381, 13)) ->C : Symbol(C, Decl(immutable.d.ts, 381, 13)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->C : Symbol(C, Decl(immutable.d.ts, 381, 13)) +>C : Symbol(C, Decl(immutable.ts, 381, 13)) +>C : Symbol(C, Decl(immutable.ts, 381, 13)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>C : Symbol(C, Decl(immutable.ts, 381, 13)) map(mapper: (value: T, key: number, iter: this) => M, context?: any): Collection.Indexed; ->map : Symbol(Indexed.map, Decl(immutable.d.ts, 381, 91)) ->M : Symbol(M, Decl(immutable.d.ts, 382, 10)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 382, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 382, 22)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 382, 31)) ->iter : Symbol(iter, Decl(immutable.d.ts, 382, 44)) ->M : Symbol(M, Decl(immutable.d.ts, 382, 10)) ->context : Symbol(context, Decl(immutable.d.ts, 382, 62)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->M : Symbol(M, Decl(immutable.d.ts, 382, 10)) +>map : Symbol(Indexed.map, Decl(immutable.ts, 381, 91)) +>M : Symbol(M, Decl(immutable.ts, 382, 10)) +>mapper : Symbol(mapper, Decl(immutable.ts, 382, 13)) +>value : Symbol(value, Decl(immutable.ts, 382, 22)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>key : Symbol(key, Decl(immutable.ts, 382, 31)) +>iter : Symbol(iter, Decl(immutable.ts, 382, 44)) +>M : Symbol(M, Decl(immutable.ts, 382, 10)) +>context : Symbol(context, Decl(immutable.ts, 382, 62)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>M : Symbol(M, Decl(immutable.ts, 382, 10)) flatMap(mapper: (value: T, key: number, iter: this) => Iterable, context?: any): Collection.Indexed; ->flatMap : Symbol(Indexed.flatMap, Decl(immutable.d.ts, 382, 101)) ->M : Symbol(M, Decl(immutable.d.ts, 383, 14)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 383, 17)) ->value : Symbol(value, Decl(immutable.d.ts, 383, 26)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->key : Symbol(key, Decl(immutable.d.ts, 383, 35)) ->iter : Symbol(iter, Decl(immutable.d.ts, 383, 48)) +>flatMap : Symbol(Indexed.flatMap, Decl(immutable.ts, 382, 101)) +>M : Symbol(M, Decl(immutable.ts, 383, 14)) +>mapper : Symbol(mapper, Decl(immutable.ts, 383, 17)) +>value : Symbol(value, Decl(immutable.ts, 383, 26)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>key : Symbol(key, Decl(immutable.ts, 383, 35)) +>iter : Symbol(iter, Decl(immutable.ts, 383, 48)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 383, 14)) ->context : Symbol(context, Decl(immutable.d.ts, 383, 76)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->M : Symbol(M, Decl(immutable.d.ts, 383, 14)) +>M : Symbol(M, Decl(immutable.ts, 383, 14)) +>context : Symbol(context, Decl(immutable.ts, 383, 76)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>M : Symbol(M, Decl(immutable.ts, 383, 14)) filter(predicate: (value: T, index: number, iter: this) => value is F, context?: any): Collection.Indexed; ->filter : Symbol(Indexed.filter, Decl(immutable.d.ts, 383, 115), Decl(immutable.d.ts, 384, 128)) ->F : Symbol(F, Decl(immutable.d.ts, 384, 13)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 384, 26)) ->value : Symbol(value, Decl(immutable.d.ts, 384, 38)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->index : Symbol(index, Decl(immutable.d.ts, 384, 47)) ->iter : Symbol(iter, Decl(immutable.d.ts, 384, 62)) ->value : Symbol(value, Decl(immutable.d.ts, 384, 38)) ->F : Symbol(F, Decl(immutable.d.ts, 384, 13)) ->context : Symbol(context, Decl(immutable.d.ts, 384, 89)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->F : Symbol(F, Decl(immutable.d.ts, 384, 13)) +>filter : Symbol(Indexed.filter, Decl(immutable.ts, 383, 115), Decl(immutable.ts, 384, 128)) +>F : Symbol(F, Decl(immutable.ts, 384, 13)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>predicate : Symbol(predicate, Decl(immutable.ts, 384, 26)) +>value : Symbol(value, Decl(immutable.ts, 384, 38)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>index : Symbol(index, Decl(immutable.ts, 384, 47)) +>iter : Symbol(iter, Decl(immutable.ts, 384, 62)) +>value : Symbol(value, Decl(immutable.ts, 384, 38)) +>F : Symbol(F, Decl(immutable.ts, 384, 13)) +>context : Symbol(context, Decl(immutable.ts, 384, 89)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>F : Symbol(F, Decl(immutable.ts, 384, 13)) filter(predicate: (value: T, index: number, iter: this) => any, context?: any): this; ->filter : Symbol(Indexed.filter, Decl(immutable.d.ts, 383, 115), Decl(immutable.d.ts, 384, 128)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 385, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 385, 25)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) ->index : Symbol(index, Decl(immutable.d.ts, 385, 34)) ->iter : Symbol(iter, Decl(immutable.d.ts, 385, 49)) ->context : Symbol(context, Decl(immutable.d.ts, 385, 69)) +>filter : Symbol(Indexed.filter, Decl(immutable.ts, 383, 115), Decl(immutable.ts, 384, 128)) +>predicate : Symbol(predicate, Decl(immutable.ts, 385, 13)) +>value : Symbol(value, Decl(immutable.ts, 385, 25)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) +>index : Symbol(index, Decl(immutable.ts, 385, 34)) +>iter : Symbol(iter, Decl(immutable.ts, 385, 49)) +>context : Symbol(context, Decl(immutable.ts, 385, 69)) [Symbol.iterator](): IterableIterator; >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 358, 29)) +>T : Symbol(T, Decl(immutable.ts, 358, 29)) } export module Set {} ->Set : Symbol(Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) +>Set : Symbol(Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) export function Set(collection: Iterable): Collection.Set; ->Set : Symbol(Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->T : Symbol(T, Decl(immutable.d.ts, 389, 24)) ->collection : Symbol(collection, Decl(immutable.d.ts, 389, 27)) +>Set : Symbol(Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>T : Symbol(T, Decl(immutable.ts, 389, 24)) +>collection : Symbol(collection, Decl(immutable.ts, 389, 27)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 389, 24)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Set : Symbol(Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->T : Symbol(T, Decl(immutable.d.ts, 389, 24)) +>T : Symbol(T, Decl(immutable.ts, 389, 24)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Set : Symbol(Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>T : Symbol(T, Decl(immutable.ts, 389, 24)) export interface Set extends Collection { ->Set : Symbol(Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) +>Set : Symbol(Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) toJS(): Array; ->toJS : Symbol(Set.toJS, Decl(immutable.d.ts, 390, 58)) +>toJS : Symbol(Set.toJS, Decl(immutable.ts, 390, 58)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) toJSON(): Array; ->toJSON : Symbol(Set.toJSON, Decl(immutable.d.ts, 391, 25)) +>toJSON : Symbol(Set.toJSON, Decl(immutable.ts, 391, 25)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) toSeq(): Seq.Set; ->toSeq : Symbol(Set.toSeq, Decl(immutable.d.ts, 392, 25)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Seq.Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) +>toSeq : Symbol(Set.toSeq, Decl(immutable.ts, 392, 25)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Seq.Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) // Sequence algorithms concat(...valuesOrCollections: Array | C>): Collection.Set; ->concat : Symbol(Set.concat, Decl(immutable.d.ts, 393, 26)) ->C : Symbol(C, Decl(immutable.d.ts, 395, 13)) ->valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.d.ts, 395, 16)) +>concat : Symbol(Set.concat, Decl(immutable.ts, 393, 26)) +>C : Symbol(C, Decl(immutable.ts, 395, 13)) +>valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.ts, 395, 16)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->C : Symbol(C, Decl(immutable.d.ts, 395, 13)) ->C : Symbol(C, Decl(immutable.d.ts, 395, 13)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Set : Symbol(Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) ->C : Symbol(C, Decl(immutable.d.ts, 395, 13)) +>C : Symbol(C, Decl(immutable.ts, 395, 13)) +>C : Symbol(C, Decl(immutable.ts, 395, 13)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Set : Symbol(Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) +>C : Symbol(C, Decl(immutable.ts, 395, 13)) map(mapper: (value: T, key: never, iter: this) => M, context?: any): Collection.Set; ->map : Symbol(Set.map, Decl(immutable.d.ts, 395, 87)) ->M : Symbol(M, Decl(immutable.d.ts, 396, 10)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 396, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 396, 22)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 396, 31)) ->iter : Symbol(iter, Decl(immutable.d.ts, 396, 43)) ->M : Symbol(M, Decl(immutable.d.ts, 396, 10)) ->context : Symbol(context, Decl(immutable.d.ts, 396, 61)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Set : Symbol(Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->M : Symbol(M, Decl(immutable.d.ts, 396, 10)) +>map : Symbol(Set.map, Decl(immutable.ts, 395, 87)) +>M : Symbol(M, Decl(immutable.ts, 396, 10)) +>mapper : Symbol(mapper, Decl(immutable.ts, 396, 13)) +>value : Symbol(value, Decl(immutable.ts, 396, 22)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) +>key : Symbol(key, Decl(immutable.ts, 396, 31)) +>iter : Symbol(iter, Decl(immutable.ts, 396, 43)) +>M : Symbol(M, Decl(immutable.ts, 396, 10)) +>context : Symbol(context, Decl(immutable.ts, 396, 61)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Set : Symbol(Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>M : Symbol(M, Decl(immutable.ts, 396, 10)) flatMap(mapper: (value: T, key: never, iter: this) => Iterable, context?: any): Collection.Set; ->flatMap : Symbol(Set.flatMap, Decl(immutable.d.ts, 396, 96)) ->M : Symbol(M, Decl(immutable.d.ts, 397, 14)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 397, 17)) ->value : Symbol(value, Decl(immutable.d.ts, 397, 26)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 397, 35)) ->iter : Symbol(iter, Decl(immutable.d.ts, 397, 47)) +>flatMap : Symbol(Set.flatMap, Decl(immutable.ts, 396, 96)) +>M : Symbol(M, Decl(immutable.ts, 397, 14)) +>mapper : Symbol(mapper, Decl(immutable.ts, 397, 17)) +>value : Symbol(value, Decl(immutable.ts, 397, 26)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) +>key : Symbol(key, Decl(immutable.ts, 397, 35)) +>iter : Symbol(iter, Decl(immutable.ts, 397, 47)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 397, 14)) ->context : Symbol(context, Decl(immutable.d.ts, 397, 75)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Set : Symbol(Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->M : Symbol(M, Decl(immutable.d.ts, 397, 14)) +>M : Symbol(M, Decl(immutable.ts, 397, 14)) +>context : Symbol(context, Decl(immutable.ts, 397, 75)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Set : Symbol(Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>M : Symbol(M, Decl(immutable.ts, 397, 14)) filter(predicate: (value: T, key: never, iter: this) => value is F, context?: any): Collection.Set; ->filter : Symbol(Set.filter, Decl(immutable.d.ts, 397, 111), Decl(immutable.d.ts, 398, 121)) ->F : Symbol(F, Decl(immutable.d.ts, 398, 13)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 398, 26)) ->value : Symbol(value, Decl(immutable.d.ts, 398, 38)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 398, 47)) ->iter : Symbol(iter, Decl(immutable.d.ts, 398, 59)) ->value : Symbol(value, Decl(immutable.d.ts, 398, 38)) ->F : Symbol(F, Decl(immutable.d.ts, 398, 13)) ->context : Symbol(context, Decl(immutable.d.ts, 398, 86)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Set : Symbol(Set, Decl(immutable.d.ts, 387, 5), Decl(immutable.d.ts, 388, 24), Decl(immutable.d.ts, 389, 71)) ->F : Symbol(F, Decl(immutable.d.ts, 398, 13)) +>filter : Symbol(Set.filter, Decl(immutable.ts, 397, 111), Decl(immutable.ts, 398, 121)) +>F : Symbol(F, Decl(immutable.ts, 398, 13)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) +>predicate : Symbol(predicate, Decl(immutable.ts, 398, 26)) +>value : Symbol(value, Decl(immutable.ts, 398, 38)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) +>key : Symbol(key, Decl(immutable.ts, 398, 47)) +>iter : Symbol(iter, Decl(immutable.ts, 398, 59)) +>value : Symbol(value, Decl(immutable.ts, 398, 38)) +>F : Symbol(F, Decl(immutable.ts, 398, 13)) +>context : Symbol(context, Decl(immutable.ts, 398, 86)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Set : Symbol(Set, Decl(immutable.ts, 387, 5), Decl(immutable.ts, 388, 24), Decl(immutable.ts, 389, 71)) +>F : Symbol(F, Decl(immutable.ts, 398, 13)) filter(predicate: (value: T, key: never, iter: this) => any, context?: any): this; ->filter : Symbol(Set.filter, Decl(immutable.d.ts, 397, 111), Decl(immutable.d.ts, 398, 121)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 399, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 399, 25)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) ->key : Symbol(key, Decl(immutable.d.ts, 399, 34)) ->iter : Symbol(iter, Decl(immutable.d.ts, 399, 46)) ->context : Symbol(context, Decl(immutable.d.ts, 399, 66)) +>filter : Symbol(Set.filter, Decl(immutable.ts, 397, 111), Decl(immutable.ts, 398, 121)) +>predicate : Symbol(predicate, Decl(immutable.ts, 399, 13)) +>value : Symbol(value, Decl(immutable.ts, 399, 25)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) +>key : Symbol(key, Decl(immutable.ts, 399, 34)) +>iter : Symbol(iter, Decl(immutable.ts, 399, 46)) +>context : Symbol(context, Decl(immutable.ts, 399, 66)) [Symbol.iterator](): IterableIterator; >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 390, 25)) +>T : Symbol(T, Decl(immutable.ts, 390, 25)) } } export function Collection>(collection: I): I; ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->I : Symbol(I, Decl(immutable.d.ts, 403, 29)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->collection : Symbol(collection, Decl(immutable.d.ts, 403, 61)) ->I : Symbol(I, Decl(immutable.d.ts, 403, 29)) ->I : Symbol(I, Decl(immutable.d.ts, 403, 29)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>I : Symbol(I, Decl(immutable.ts, 403, 29)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>collection : Symbol(collection, Decl(immutable.ts, 403, 61)) +>I : Symbol(I, Decl(immutable.ts, 403, 29)) +>I : Symbol(I, Decl(immutable.ts, 403, 29)) export function Collection(collection: Iterable): Collection.Indexed; ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->T : Symbol(T, Decl(immutable.d.ts, 404, 29)) ->collection : Symbol(collection, Decl(immutable.d.ts, 404, 32)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>T : Symbol(T, Decl(immutable.ts, 404, 29)) +>collection : Symbol(collection, Decl(immutable.ts, 404, 32)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(immutable.d.ts, 404, 29)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Indexed : Symbol(Collection.Indexed, Decl(immutable.d.ts, 355, 5), Decl(immutable.d.ts, 356, 28), Decl(immutable.d.ts, 357, 79)) ->T : Symbol(T, Decl(immutable.d.ts, 404, 29)) +>T : Symbol(T, Decl(immutable.ts, 404, 29)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Indexed : Symbol(Collection.Indexed, Decl(immutable.ts, 355, 5), Decl(immutable.ts, 356, 28), Decl(immutable.ts, 357, 79)) +>T : Symbol(T, Decl(immutable.ts, 404, 29)) export function Collection(obj: {[key: string]: V}): Collection.Keyed; ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->V : Symbol(V, Decl(immutable.d.ts, 405, 29)) ->obj : Symbol(obj, Decl(immutable.d.ts, 405, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 405, 39)) ->V : Symbol(V, Decl(immutable.d.ts, 405, 29)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->Keyed : Symbol(Collection.Keyed, Decl(immutable.d.ts, 336, 51), Decl(immutable.d.ts, 337, 26), Decl(immutable.d.ts, 338, 86), Decl(immutable.d.ts, 339, 83)) ->V : Symbol(V, Decl(immutable.d.ts, 405, 29)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>V : Symbol(V, Decl(immutable.ts, 405, 29)) +>obj : Symbol(obj, Decl(immutable.ts, 405, 32)) +>key : Symbol(key, Decl(immutable.ts, 405, 39)) +>V : Symbol(V, Decl(immutable.ts, 405, 29)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>Keyed : Symbol(Collection.Keyed, Decl(immutable.ts, 336, 51), Decl(immutable.ts, 337, 26), Decl(immutable.ts, 338, 86), Decl(immutable.ts, 339, 83)) +>V : Symbol(V, Decl(immutable.ts, 405, 29)) export interface Collection extends ValueObject { ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->ValueObject : Symbol(ValueObject, Decl(immutable.d.ts, 13, 76)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>ValueObject : Symbol(ValueObject, Decl(immutable.ts, 13, 76)) // Value equality equals(other: any): boolean; ->equals : Symbol(Collection.equals, Decl(immutable.d.ts, 406, 57)) ->other : Symbol(other, Decl(immutable.d.ts, 408, 11)) +>equals : Symbol(Collection.equals, Decl(immutable.ts, 406, 57)) +>other : Symbol(other, Decl(immutable.ts, 408, 11)) hashCode(): number; ->hashCode : Symbol(Collection.hashCode, Decl(immutable.d.ts, 408, 32)) +>hashCode : Symbol(Collection.hashCode, Decl(immutable.ts, 408, 32)) // Reading values get(key: K, notSetValue: NSV): V | NSV; ->get : Symbol(Collection.get, Decl(immutable.d.ts, 409, 23), Decl(immutable.d.ts, 411, 48)) ->NSV : Symbol(NSV, Decl(immutable.d.ts, 411, 8)) ->key : Symbol(key, Decl(immutable.d.ts, 411, 13)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 411, 20)) ->NSV : Symbol(NSV, Decl(immutable.d.ts, 411, 8)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->NSV : Symbol(NSV, Decl(immutable.d.ts, 411, 8)) +>get : Symbol(Collection.get, Decl(immutable.ts, 409, 23), Decl(immutable.ts, 411, 48)) +>NSV : Symbol(NSV, Decl(immutable.ts, 411, 8)) +>key : Symbol(key, Decl(immutable.ts, 411, 13)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 411, 20)) +>NSV : Symbol(NSV, Decl(immutable.ts, 411, 8)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>NSV : Symbol(NSV, Decl(immutable.ts, 411, 8)) get(key: K): V | undefined; ->get : Symbol(Collection.get, Decl(immutable.d.ts, 409, 23), Decl(immutable.d.ts, 411, 48)) ->key : Symbol(key, Decl(immutable.d.ts, 412, 8)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>get : Symbol(Collection.get, Decl(immutable.ts, 409, 23), Decl(immutable.ts, 411, 48)) +>key : Symbol(key, Decl(immutable.ts, 412, 8)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) has(key: K): boolean; ->has : Symbol(Collection.has, Decl(immutable.d.ts, 412, 31)) ->key : Symbol(key, Decl(immutable.d.ts, 413, 8)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) +>has : Symbol(Collection.has, Decl(immutable.ts, 412, 31)) +>key : Symbol(key, Decl(immutable.ts, 413, 8)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) includes(value: V): boolean; ->includes : Symbol(Collection.includes, Decl(immutable.d.ts, 413, 25)) ->value : Symbol(value, Decl(immutable.d.ts, 414, 13)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>includes : Symbol(Collection.includes, Decl(immutable.ts, 413, 25)) +>value : Symbol(value, Decl(immutable.ts, 414, 13)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) contains(value: V): boolean; ->contains : Symbol(Collection.contains, Decl(immutable.d.ts, 414, 32)) ->value : Symbol(value, Decl(immutable.d.ts, 415, 13)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>contains : Symbol(Collection.contains, Decl(immutable.ts, 414, 32)) +>value : Symbol(value, Decl(immutable.ts, 415, 13)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) first(): V | undefined; ->first : Symbol(Collection.first, Decl(immutable.d.ts, 415, 32)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>first : Symbol(Collection.first, Decl(immutable.ts, 415, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) last(): V | undefined; ->last : Symbol(Collection.last, Decl(immutable.d.ts, 416, 27)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>last : Symbol(Collection.last, Decl(immutable.ts, 416, 27)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) // Reading deep values getIn(searchKeyPath: Iterable, notSetValue?: any): any; ->getIn : Symbol(Collection.getIn, Decl(immutable.d.ts, 417, 26)) ->searchKeyPath : Symbol(searchKeyPath, Decl(immutable.d.ts, 419, 10)) +>getIn : Symbol(Collection.getIn, Decl(immutable.ts, 417, 26)) +>searchKeyPath : Symbol(searchKeyPath, Decl(immutable.ts, 419, 10)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 419, 39)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 419, 39)) hasIn(searchKeyPath: Iterable): boolean; ->hasIn : Symbol(Collection.hasIn, Decl(immutable.d.ts, 419, 64)) ->searchKeyPath : Symbol(searchKeyPath, Decl(immutable.d.ts, 420, 10)) +>hasIn : Symbol(Collection.hasIn, Decl(immutable.ts, 419, 64)) +>searchKeyPath : Symbol(searchKeyPath, Decl(immutable.ts, 420, 10)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) // Persistent changes update(updater: (value: this) => R): R; ->update : Symbol(Collection.update, Decl(immutable.d.ts, 420, 49)) ->R : Symbol(R, Decl(immutable.d.ts, 422, 11)) ->updater : Symbol(updater, Decl(immutable.d.ts, 422, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 422, 24)) ->R : Symbol(R, Decl(immutable.d.ts, 422, 11)) ->R : Symbol(R, Decl(immutable.d.ts, 422, 11)) +>update : Symbol(Collection.update, Decl(immutable.ts, 420, 49)) +>R : Symbol(R, Decl(immutable.ts, 422, 11)) +>updater : Symbol(updater, Decl(immutable.ts, 422, 14)) +>value : Symbol(value, Decl(immutable.ts, 422, 24)) +>R : Symbol(R, Decl(immutable.ts, 422, 11)) +>R : Symbol(R, Decl(immutable.ts, 422, 11)) // Conversion to JavaScript types toJS(): Array | { [key: string]: any }; ->toJS : Symbol(Collection.toJS, Decl(immutable.d.ts, 422, 46)) +>toJS : Symbol(Collection.toJS, Decl(immutable.ts, 422, 46)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->key : Symbol(key, Decl(immutable.d.ts, 424, 28)) +>key : Symbol(key, Decl(immutable.ts, 424, 28)) toJSON(): Array | { [key: string]: V }; ->toJSON : Symbol(Collection.toJSON, Decl(immutable.d.ts, 424, 48)) +>toJSON : Symbol(Collection.toJSON, Decl(immutable.ts, 424, 48)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 425, 28)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 425, 28)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) toArray(): Array; ->toArray : Symbol(Collection.toArray, Decl(immutable.d.ts, 425, 46)) +>toArray : Symbol(Collection.toArray, Decl(immutable.ts, 425, 46)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) toObject(): { [key: string]: V }; ->toObject : Symbol(Collection.toObject, Decl(immutable.d.ts, 426, 24)) ->key : Symbol(key, Decl(immutable.d.ts, 427, 19)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toObject : Symbol(Collection.toObject, Decl(immutable.ts, 426, 24)) +>key : Symbol(key, Decl(immutable.ts, 427, 19)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) // Conversion to Collections toMap(): Map; ->toMap : Symbol(Collection.toMap, Decl(immutable.d.ts, 427, 37)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toMap : Symbol(Collection.toMap, Decl(immutable.ts, 427, 37)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) toOrderedMap(): OrderedMap; ->toOrderedMap : Symbol(Collection.toOrderedMap, Decl(immutable.d.ts, 429, 23)) ->OrderedMap : Symbol(OrderedMap, Decl(immutable.d.ts, 108, 3), Decl(immutable.d.ts, 111, 3), Decl(immutable.d.ts, 112, 83), Decl(immutable.d.ts, 113, 85), Decl(immutable.d.ts, 114, 80) ... and 2 more) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toOrderedMap : Symbol(Collection.toOrderedMap, Decl(immutable.ts, 429, 23)) +>OrderedMap : Symbol(OrderedMap, Decl(immutable.ts, 108, 3), Decl(immutable.ts, 111, 3), Decl(immutable.ts, 112, 83), Decl(immutable.ts, 113, 85), Decl(immutable.ts, 114, 80) ... and 2 more) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) toSet(): Set; ->toSet : Symbol(Collection.toSet, Decl(immutable.d.ts, 430, 37)) ->Set : Symbol(Set, Decl(immutable.d.ts, 127, 3), Decl(immutable.d.ts, 135, 3), Decl(immutable.d.ts, 136, 34), Decl(immutable.d.ts, 137, 35), Decl(immutable.d.ts, 138, 58)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toSet : Symbol(Collection.toSet, Decl(immutable.ts, 430, 37)) +>Set : Symbol(Set, Decl(immutable.ts, 127, 3), Decl(immutable.ts, 135, 3), Decl(immutable.ts, 136, 34), Decl(immutable.ts, 137, 35), Decl(immutable.ts, 138, 58)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) toOrderedSet(): OrderedSet; ->toOrderedSet : Symbol(Collection.toOrderedSet, Decl(immutable.d.ts, 431, 20)) ->OrderedSet : Symbol(OrderedSet, Decl(immutable.d.ts, 159, 3), Decl(immutable.d.ts, 165, 3), Decl(immutable.d.ts, 166, 48), Decl(immutable.d.ts, 167, 49), Decl(immutable.d.ts, 168, 72)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toOrderedSet : Symbol(Collection.toOrderedSet, Decl(immutable.ts, 431, 20)) +>OrderedSet : Symbol(OrderedSet, Decl(immutable.ts, 159, 3), Decl(immutable.ts, 165, 3), Decl(immutable.ts, 166, 48), Decl(immutable.ts, 167, 49), Decl(immutable.ts, 168, 72)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) toList(): List; ->toList : Symbol(Collection.toList, Decl(immutable.d.ts, 432, 34)) ->List : Symbol(List, Decl(immutable.d.ts, 17, 3), Decl(immutable.d.ts, 21, 3), Decl(immutable.d.ts, 22, 36), Decl(immutable.d.ts, 23, 37), Decl(immutable.d.ts, 24, 60)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toList : Symbol(Collection.toList, Decl(immutable.ts, 432, 34)) +>List : Symbol(List, Decl(immutable.ts, 17, 3), Decl(immutable.ts, 21, 3), Decl(immutable.ts, 22, 36), Decl(immutable.ts, 23, 37), Decl(immutable.ts, 24, 60)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) toStack(): Stack; ->toStack : Symbol(Collection.toStack, Decl(immutable.d.ts, 433, 22)) ->Stack : Symbol(Stack, Decl(immutable.d.ts, 180, 3), Decl(immutable.d.ts, 184, 3), Decl(immutable.d.ts, 185, 38), Decl(immutable.d.ts, 186, 39), Decl(immutable.d.ts, 187, 62)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toStack : Symbol(Collection.toStack, Decl(immutable.ts, 433, 22)) +>Stack : Symbol(Stack, Decl(immutable.ts, 180, 3), Decl(immutable.ts, 184, 3), Decl(immutable.ts, 185, 38), Decl(immutable.ts, 186, 39), Decl(immutable.ts, 187, 62)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) // Conversion to Seq toSeq(): this; ->toSeq : Symbol(Collection.toSeq, Decl(immutable.d.ts, 434, 24)) +>toSeq : Symbol(Collection.toSeq, Decl(immutable.ts, 434, 24)) toKeyedSeq(): Seq.Keyed; ->toKeyedSeq : Symbol(Collection.toKeyedSeq, Decl(immutable.d.ts, 436, 18)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Seq.Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toKeyedSeq : Symbol(Collection.toKeyedSeq, Decl(immutable.ts, 436, 18)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Seq.Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) toIndexedSeq(): Seq.Indexed; ->toIndexedSeq : Symbol(Collection.toIndexedSeq, Decl(immutable.d.ts, 437, 34)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Seq.Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toIndexedSeq : Symbol(Collection.toIndexedSeq, Decl(immutable.ts, 437, 34)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Seq.Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) toSetSeq(): Seq.Set; ->toSetSeq : Symbol(Collection.toSetSeq, Decl(immutable.d.ts, 438, 35)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Set : Symbol(Seq.Set, Decl(immutable.d.ts, 297, 5), Decl(immutable.d.ts, 300, 5), Decl(immutable.d.ts, 301, 40), Decl(immutable.d.ts, 302, 41), Decl(immutable.d.ts, 303, 64)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>toSetSeq : Symbol(Collection.toSetSeq, Decl(immutable.ts, 438, 35)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Set : Symbol(Seq.Set, Decl(immutable.ts, 297, 5), Decl(immutable.ts, 300, 5), Decl(immutable.ts, 301, 40), Decl(immutable.ts, 302, 41), Decl(immutable.ts, 303, 64)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) // Iterators keys(): IterableIterator; ->keys : Symbol(Collection.keys, Decl(immutable.d.ts, 439, 27)) +>keys : Symbol(Collection.keys, Decl(immutable.ts, 439, 27)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) values(): IterableIterator; ->values : Symbol(Collection.values, Decl(immutable.d.ts, 441, 32)) +>values : Symbol(Collection.values, Decl(immutable.ts, 441, 32)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) entries(): IterableIterator<[K, V]>; ->entries : Symbol(Collection.entries, Decl(immutable.d.ts, 442, 34)) +>entries : Symbol(Collection.entries, Decl(immutable.ts, 442, 34)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) // Collections (Seq) keySeq(): Seq.Indexed; ->keySeq : Symbol(Collection.keySeq, Decl(immutable.d.ts, 443, 40)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Seq.Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) +>keySeq : Symbol(Collection.keySeq, Decl(immutable.ts, 443, 40)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Seq.Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) valueSeq(): Seq.Indexed; ->valueSeq : Symbol(Collection.valueSeq, Decl(immutable.d.ts, 445, 29)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Seq.Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>valueSeq : Symbol(Collection.valueSeq, Decl(immutable.ts, 445, 29)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Seq.Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) entrySeq(): Seq.Indexed<[K, V]>; ->entrySeq : Symbol(Collection.entrySeq, Decl(immutable.d.ts, 446, 31)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Indexed : Symbol(Seq.Indexed, Decl(immutable.d.ts, 281, 5), Decl(immutable.d.ts, 284, 5), Decl(immutable.d.ts, 285, 48), Decl(immutable.d.ts, 286, 49), Decl(immutable.d.ts, 287, 72)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>entrySeq : Symbol(Collection.entrySeq, Decl(immutable.ts, 446, 31)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Indexed : Symbol(Seq.Indexed, Decl(immutable.ts, 281, 5), Decl(immutable.ts, 284, 5), Decl(immutable.ts, 285, 48), Decl(immutable.ts, 286, 49), Decl(immutable.ts, 287, 72)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) // Sequence algorithms map(mapper: (value: V, key: K, iter: this) => M, context?: any): Collection; ->map : Symbol(Collection.map, Decl(immutable.d.ts, 447, 36)) ->M : Symbol(M, Decl(immutable.d.ts, 449, 8)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 449, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 449, 20)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 449, 29)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 449, 37)) ->M : Symbol(M, Decl(immutable.d.ts, 449, 8)) ->context : Symbol(context, Decl(immutable.d.ts, 449, 55)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->M : Symbol(M, Decl(immutable.d.ts, 449, 8)) +>map : Symbol(Collection.map, Decl(immutable.ts, 447, 36)) +>M : Symbol(M, Decl(immutable.ts, 449, 8)) +>mapper : Symbol(mapper, Decl(immutable.ts, 449, 11)) +>value : Symbol(value, Decl(immutable.ts, 449, 20)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 449, 29)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 449, 37)) +>M : Symbol(M, Decl(immutable.ts, 449, 8)) +>context : Symbol(context, Decl(immutable.ts, 449, 55)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>M : Symbol(M, Decl(immutable.ts, 449, 8)) filter(predicate: (value: V, key: K, iter: this) => value is F, context?: any): Collection; ->filter : Symbol(Collection.filter, Decl(immutable.d.ts, 449, 89), Decl(immutable.d.ts, 450, 114)) ->F : Symbol(F, Decl(immutable.d.ts, 450, 11)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 450, 24)) ->value : Symbol(value, Decl(immutable.d.ts, 450, 36)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 450, 45)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 450, 53)) ->value : Symbol(value, Decl(immutable.d.ts, 450, 36)) ->F : Symbol(F, Decl(immutable.d.ts, 450, 11)) ->context : Symbol(context, Decl(immutable.d.ts, 450, 80)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->F : Symbol(F, Decl(immutable.d.ts, 450, 11)) +>filter : Symbol(Collection.filter, Decl(immutable.ts, 449, 89), Decl(immutable.ts, 450, 114)) +>F : Symbol(F, Decl(immutable.ts, 450, 11)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>predicate : Symbol(predicate, Decl(immutable.ts, 450, 24)) +>value : Symbol(value, Decl(immutable.ts, 450, 36)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 450, 45)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 450, 53)) +>value : Symbol(value, Decl(immutable.ts, 450, 36)) +>F : Symbol(F, Decl(immutable.ts, 450, 11)) +>context : Symbol(context, Decl(immutable.ts, 450, 80)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>F : Symbol(F, Decl(immutable.ts, 450, 11)) filter(predicate: (value: V, key: K, iter: this) => any, context?: any): this; ->filter : Symbol(Collection.filter, Decl(immutable.d.ts, 449, 89), Decl(immutable.d.ts, 450, 114)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 451, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 451, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 451, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 451, 40)) ->context : Symbol(context, Decl(immutable.d.ts, 451, 60)) +>filter : Symbol(Collection.filter, Decl(immutable.ts, 449, 89), Decl(immutable.ts, 450, 114)) +>predicate : Symbol(predicate, Decl(immutable.ts, 451, 11)) +>value : Symbol(value, Decl(immutable.ts, 451, 23)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 451, 32)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 451, 40)) +>context : Symbol(context, Decl(immutable.ts, 451, 60)) filterNot(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; ->filterNot : Symbol(Collection.filterNot, Decl(immutable.d.ts, 451, 82)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 452, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 452, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 452, 35)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 452, 43)) ->context : Symbol(context, Decl(immutable.d.ts, 452, 67)) +>filterNot : Symbol(Collection.filterNot, Decl(immutable.ts, 451, 82)) +>predicate : Symbol(predicate, Decl(immutable.ts, 452, 14)) +>value : Symbol(value, Decl(immutable.ts, 452, 26)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 452, 35)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 452, 43)) +>context : Symbol(context, Decl(immutable.ts, 452, 67)) reverse(): this; ->reverse : Symbol(Collection.reverse, Decl(immutable.d.ts, 452, 89)) +>reverse : Symbol(Collection.reverse, Decl(immutable.ts, 452, 89)) sort(comparator?: (valueA: V, valueB: V) => number): this; ->sort : Symbol(Collection.sort, Decl(immutable.d.ts, 453, 20)) ->comparator : Symbol(comparator, Decl(immutable.d.ts, 454, 9)) ->valueA : Symbol(valueA, Decl(immutable.d.ts, 454, 23)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->valueB : Symbol(valueB, Decl(immutable.d.ts, 454, 33)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>sort : Symbol(Collection.sort, Decl(immutable.ts, 453, 20)) +>comparator : Symbol(comparator, Decl(immutable.ts, 454, 9)) +>valueA : Symbol(valueA, Decl(immutable.ts, 454, 23)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>valueB : Symbol(valueB, Decl(immutable.ts, 454, 33)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) sortBy(comparatorValueMapper: (value: V, key: K, iter: this) => C, comparator?: (valueA: C, valueB: C) => number): this; ->sortBy : Symbol(Collection.sortBy, Decl(immutable.d.ts, 454, 62)) ->C : Symbol(C, Decl(immutable.d.ts, 455, 11)) ->comparatorValueMapper : Symbol(comparatorValueMapper, Decl(immutable.d.ts, 455, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 455, 38)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 455, 47)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 455, 55)) ->C : Symbol(C, Decl(immutable.d.ts, 455, 11)) ->comparator : Symbol(comparator, Decl(immutable.d.ts, 455, 73)) ->valueA : Symbol(valueA, Decl(immutable.d.ts, 455, 88)) ->C : Symbol(C, Decl(immutable.d.ts, 455, 11)) ->valueB : Symbol(valueB, Decl(immutable.d.ts, 455, 98)) ->C : Symbol(C, Decl(immutable.d.ts, 455, 11)) +>sortBy : Symbol(Collection.sortBy, Decl(immutable.ts, 454, 62)) +>C : Symbol(C, Decl(immutable.ts, 455, 11)) +>comparatorValueMapper : Symbol(comparatorValueMapper, Decl(immutable.ts, 455, 14)) +>value : Symbol(value, Decl(immutable.ts, 455, 38)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 455, 47)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 455, 55)) +>C : Symbol(C, Decl(immutable.ts, 455, 11)) +>comparator : Symbol(comparator, Decl(immutable.ts, 455, 73)) +>valueA : Symbol(valueA, Decl(immutable.ts, 455, 88)) +>C : Symbol(C, Decl(immutable.ts, 455, 11)) +>valueB : Symbol(valueB, Decl(immutable.ts, 455, 98)) +>C : Symbol(C, Decl(immutable.ts, 455, 11)) groupBy(grouper: (value: V, key: K, iter: this) => G, context?: any): /*Map*/Seq.Keyed>; ->groupBy : Symbol(Collection.groupBy, Decl(immutable.d.ts, 455, 127)) ->G : Symbol(G, Decl(immutable.d.ts, 456, 12)) ->grouper : Symbol(grouper, Decl(immutable.d.ts, 456, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 456, 25)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 456, 34)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 456, 42)) ->G : Symbol(G, Decl(immutable.d.ts, 456, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 456, 60)) ->Seq : Symbol(Seq, Decl(immutable.d.ts, 260, 78), Decl(immutable.d.ts, 314, 3), Decl(immutable.d.ts, 315, 58), Decl(immutable.d.ts, 316, 81), Decl(immutable.d.ts, 317, 76) ... and 4 more) ->Keyed : Symbol(Seq.Keyed, Decl(immutable.d.ts, 263, 56), Decl(immutable.d.ts, 264, 26), Decl(immutable.d.ts, 265, 79), Decl(immutable.d.ts, 266, 76), Decl(immutable.d.ts, 267, 51) ... and 1 more) ->G : Symbol(G, Decl(immutable.d.ts, 456, 12)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>groupBy : Symbol(Collection.groupBy, Decl(immutable.ts, 455, 127)) +>G : Symbol(G, Decl(immutable.ts, 456, 12)) +>grouper : Symbol(grouper, Decl(immutable.ts, 456, 15)) +>value : Symbol(value, Decl(immutable.ts, 456, 25)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 456, 34)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 456, 42)) +>G : Symbol(G, Decl(immutable.ts, 456, 12)) +>context : Symbol(context, Decl(immutable.ts, 456, 60)) +>Seq : Symbol(Seq, Decl(immutable.ts, 260, 78), Decl(immutable.ts, 314, 3), Decl(immutable.ts, 315, 58), Decl(immutable.ts, 316, 81), Decl(immutable.ts, 317, 76) ... and 4 more) +>Keyed : Symbol(Seq.Keyed, Decl(immutable.ts, 263, 56), Decl(immutable.ts, 264, 26), Decl(immutable.ts, 265, 79), Decl(immutable.ts, 266, 76), Decl(immutable.ts, 267, 51) ... and 1 more) +>G : Symbol(G, Decl(immutable.ts, 456, 12)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) // Side effects forEach(sideEffect: (value: V, key: K, iter: this) => any, context?: any): number; ->forEach : Symbol(Collection.forEach, Decl(immutable.d.ts, 456, 123)) ->sideEffect : Symbol(sideEffect, Decl(immutable.d.ts, 458, 12)) ->value : Symbol(value, Decl(immutable.d.ts, 458, 25)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 458, 34)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 458, 42)) ->context : Symbol(context, Decl(immutable.d.ts, 458, 62)) +>forEach : Symbol(Collection.forEach, Decl(immutable.ts, 456, 123)) +>sideEffect : Symbol(sideEffect, Decl(immutable.ts, 458, 12)) +>value : Symbol(value, Decl(immutable.ts, 458, 25)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 458, 34)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 458, 42)) +>context : Symbol(context, Decl(immutable.ts, 458, 62)) // Creating subsets slice(begin?: number, end?: number): this; ->slice : Symbol(Collection.slice, Decl(immutable.d.ts, 458, 86)) ->begin : Symbol(begin, Decl(immutable.d.ts, 460, 10)) ->end : Symbol(end, Decl(immutable.d.ts, 460, 25)) +>slice : Symbol(Collection.slice, Decl(immutable.ts, 458, 86)) +>begin : Symbol(begin, Decl(immutable.ts, 460, 10)) +>end : Symbol(end, Decl(immutable.ts, 460, 25)) rest(): this; ->rest : Symbol(Collection.rest, Decl(immutable.d.ts, 460, 46)) +>rest : Symbol(Collection.rest, Decl(immutable.ts, 460, 46)) butLast(): this; ->butLast : Symbol(Collection.butLast, Decl(immutable.d.ts, 461, 17)) +>butLast : Symbol(Collection.butLast, Decl(immutable.ts, 461, 17)) skip(amount: number): this; ->skip : Symbol(Collection.skip, Decl(immutable.d.ts, 462, 20)) ->amount : Symbol(amount, Decl(immutable.d.ts, 463, 9)) +>skip : Symbol(Collection.skip, Decl(immutable.ts, 462, 20)) +>amount : Symbol(amount, Decl(immutable.ts, 463, 9)) skipLast(amount: number): this; ->skipLast : Symbol(Collection.skipLast, Decl(immutable.d.ts, 463, 31)) ->amount : Symbol(amount, Decl(immutable.d.ts, 464, 13)) +>skipLast : Symbol(Collection.skipLast, Decl(immutable.ts, 463, 31)) +>amount : Symbol(amount, Decl(immutable.ts, 464, 13)) skipWhile(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; ->skipWhile : Symbol(Collection.skipWhile, Decl(immutable.d.ts, 464, 35)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 465, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 465, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 465, 35)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 465, 43)) ->context : Symbol(context, Decl(immutable.d.ts, 465, 67)) +>skipWhile : Symbol(Collection.skipWhile, Decl(immutable.ts, 464, 35)) +>predicate : Symbol(predicate, Decl(immutable.ts, 465, 14)) +>value : Symbol(value, Decl(immutable.ts, 465, 26)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 465, 35)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 465, 43)) +>context : Symbol(context, Decl(immutable.ts, 465, 67)) skipUntil(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; ->skipUntil : Symbol(Collection.skipUntil, Decl(immutable.d.ts, 465, 89)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 466, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 466, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 466, 35)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 466, 43)) ->context : Symbol(context, Decl(immutable.d.ts, 466, 67)) +>skipUntil : Symbol(Collection.skipUntil, Decl(immutable.ts, 465, 89)) +>predicate : Symbol(predicate, Decl(immutable.ts, 466, 14)) +>value : Symbol(value, Decl(immutable.ts, 466, 26)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 466, 35)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 466, 43)) +>context : Symbol(context, Decl(immutable.ts, 466, 67)) take(amount: number): this; ->take : Symbol(Collection.take, Decl(immutable.d.ts, 466, 89)) ->amount : Symbol(amount, Decl(immutable.d.ts, 467, 9)) +>take : Symbol(Collection.take, Decl(immutable.ts, 466, 89)) +>amount : Symbol(amount, Decl(immutable.ts, 467, 9)) takeLast(amount: number): this; ->takeLast : Symbol(Collection.takeLast, Decl(immutable.d.ts, 467, 31)) ->amount : Symbol(amount, Decl(immutable.d.ts, 468, 13)) +>takeLast : Symbol(Collection.takeLast, Decl(immutable.ts, 467, 31)) +>amount : Symbol(amount, Decl(immutable.ts, 468, 13)) takeWhile(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; ->takeWhile : Symbol(Collection.takeWhile, Decl(immutable.d.ts, 468, 35)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 469, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 469, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 469, 35)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 469, 43)) ->context : Symbol(context, Decl(immutable.d.ts, 469, 67)) +>takeWhile : Symbol(Collection.takeWhile, Decl(immutable.ts, 468, 35)) +>predicate : Symbol(predicate, Decl(immutable.ts, 469, 14)) +>value : Symbol(value, Decl(immutable.ts, 469, 26)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 469, 35)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 469, 43)) +>context : Symbol(context, Decl(immutable.ts, 469, 67)) takeUntil(predicate: (value: V, key: K, iter: this) => boolean, context?: any): this; ->takeUntil : Symbol(Collection.takeUntil, Decl(immutable.d.ts, 469, 89)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 470, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 470, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 470, 35)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 470, 43)) ->context : Symbol(context, Decl(immutable.d.ts, 470, 67)) +>takeUntil : Symbol(Collection.takeUntil, Decl(immutable.ts, 469, 89)) +>predicate : Symbol(predicate, Decl(immutable.ts, 470, 14)) +>value : Symbol(value, Decl(immutable.ts, 470, 26)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 470, 35)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 470, 43)) +>context : Symbol(context, Decl(immutable.ts, 470, 67)) // Combination concat(...valuesOrCollections: Array): Collection; ->concat : Symbol(Collection.concat, Decl(immutable.d.ts, 470, 89)) ->valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.d.ts, 472, 11)) +>concat : Symbol(Collection.concat, Decl(immutable.ts, 470, 89)) +>valuesOrCollections : Symbol(valuesOrCollections, Decl(immutable.ts, 472, 11)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) flatten(depth?: number): Collection; ->flatten : Symbol(Collection.flatten, Decl(immutable.d.ts, 472, 69), Decl(immutable.d.ts, 473, 50)) ->depth : Symbol(depth, Decl(immutable.d.ts, 473, 12)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) +>flatten : Symbol(Collection.flatten, Decl(immutable.ts, 472, 69), Decl(immutable.ts, 473, 50)) +>depth : Symbol(depth, Decl(immutable.ts, 473, 12)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) flatten(shallow?: boolean): Collection; ->flatten : Symbol(Collection.flatten, Decl(immutable.d.ts, 472, 69), Decl(immutable.d.ts, 473, 50)) ->shallow : Symbol(shallow, Decl(immutable.d.ts, 474, 12)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) +>flatten : Symbol(Collection.flatten, Decl(immutable.ts, 472, 69), Decl(immutable.ts, 473, 50)) +>shallow : Symbol(shallow, Decl(immutable.ts, 474, 12)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) flatMap(mapper: (value: V, key: K, iter: this) => Iterable, context?: any): Collection; ->flatMap : Symbol(Collection.flatMap, Decl(immutable.d.ts, 474, 53)) ->M : Symbol(M, Decl(immutable.d.ts, 475, 12)) ->mapper : Symbol(mapper, Decl(immutable.d.ts, 475, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 475, 24)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 475, 33)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 475, 41)) +>flatMap : Symbol(Collection.flatMap, Decl(immutable.ts, 474, 53)) +>M : Symbol(M, Decl(immutable.ts, 475, 12)) +>mapper : Symbol(mapper, Decl(immutable.ts, 475, 15)) +>value : Symbol(value, Decl(immutable.ts, 475, 24)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 475, 33)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 475, 41)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->M : Symbol(M, Decl(immutable.d.ts, 475, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 475, 69)) ->Collection : Symbol(Collection, Decl(immutable.d.ts, 331, 3), Decl(immutable.d.ts, 402, 3), Decl(immutable.d.ts, 403, 79), Decl(immutable.d.ts, 404, 80), Decl(immutable.d.ts, 405, 86)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->M : Symbol(M, Decl(immutable.d.ts, 475, 12)) +>M : Symbol(M, Decl(immutable.ts, 475, 12)) +>context : Symbol(context, Decl(immutable.ts, 475, 69)) +>Collection : Symbol(Collection, Decl(immutable.ts, 331, 3), Decl(immutable.ts, 402, 3), Decl(immutable.ts, 403, 79), Decl(immutable.ts, 404, 80), Decl(immutable.ts, 405, 86)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>M : Symbol(M, Decl(immutable.ts, 475, 12)) // Reducing a value reduce(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R; ->reduce : Symbol(Collection.reduce, Decl(immutable.d.ts, 475, 103), Decl(immutable.d.ts, 477, 113)) ->R : Symbol(R, Decl(immutable.d.ts, 477, 11)) ->reducer : Symbol(reducer, Decl(immutable.d.ts, 477, 14)) ->reduction : Symbol(reduction, Decl(immutable.d.ts, 477, 24)) ->R : Symbol(R, Decl(immutable.d.ts, 477, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 477, 37)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 477, 47)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 477, 55)) ->R : Symbol(R, Decl(immutable.d.ts, 477, 11)) ->initialReduction : Symbol(initialReduction, Decl(immutable.d.ts, 477, 73)) ->R : Symbol(R, Decl(immutable.d.ts, 477, 11)) ->context : Symbol(context, Decl(immutable.d.ts, 477, 94)) ->R : Symbol(R, Decl(immutable.d.ts, 477, 11)) +>reduce : Symbol(Collection.reduce, Decl(immutable.ts, 475, 103), Decl(immutable.ts, 477, 113)) +>R : Symbol(R, Decl(immutable.ts, 477, 11)) +>reducer : Symbol(reducer, Decl(immutable.ts, 477, 14)) +>reduction : Symbol(reduction, Decl(immutable.ts, 477, 24)) +>R : Symbol(R, Decl(immutable.ts, 477, 11)) +>value : Symbol(value, Decl(immutable.ts, 477, 37)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 477, 47)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 477, 55)) +>R : Symbol(R, Decl(immutable.ts, 477, 11)) +>initialReduction : Symbol(initialReduction, Decl(immutable.ts, 477, 73)) +>R : Symbol(R, Decl(immutable.ts, 477, 11)) +>context : Symbol(context, Decl(immutable.ts, 477, 94)) +>R : Symbol(R, Decl(immutable.ts, 477, 11)) reduce(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; ->reduce : Symbol(Collection.reduce, Decl(immutable.d.ts, 475, 103), Decl(immutable.d.ts, 477, 113)) ->R : Symbol(R, Decl(immutable.d.ts, 478, 11)) ->reducer : Symbol(reducer, Decl(immutable.d.ts, 478, 14)) ->reduction : Symbol(reduction, Decl(immutable.d.ts, 478, 24)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->R : Symbol(R, Decl(immutable.d.ts, 478, 11)) ->value : Symbol(value, Decl(immutable.d.ts, 478, 41)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 478, 51)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 478, 59)) ->R : Symbol(R, Decl(immutable.d.ts, 478, 11)) ->R : Symbol(R, Decl(immutable.d.ts, 478, 11)) +>reduce : Symbol(Collection.reduce, Decl(immutable.ts, 475, 103), Decl(immutable.ts, 477, 113)) +>R : Symbol(R, Decl(immutable.ts, 478, 11)) +>reducer : Symbol(reducer, Decl(immutable.ts, 478, 14)) +>reduction : Symbol(reduction, Decl(immutable.ts, 478, 24)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>R : Symbol(R, Decl(immutable.ts, 478, 11)) +>value : Symbol(value, Decl(immutable.ts, 478, 41)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 478, 51)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 478, 59)) +>R : Symbol(R, Decl(immutable.ts, 478, 11)) +>R : Symbol(R, Decl(immutable.ts, 478, 11)) reduceRight(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R; ->reduceRight : Symbol(Collection.reduceRight, Decl(immutable.d.ts, 478, 81), Decl(immutable.d.ts, 479, 118)) ->R : Symbol(R, Decl(immutable.d.ts, 479, 16)) ->reducer : Symbol(reducer, Decl(immutable.d.ts, 479, 19)) ->reduction : Symbol(reduction, Decl(immutable.d.ts, 479, 29)) ->R : Symbol(R, Decl(immutable.d.ts, 479, 16)) ->value : Symbol(value, Decl(immutable.d.ts, 479, 42)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 479, 52)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 479, 60)) ->R : Symbol(R, Decl(immutable.d.ts, 479, 16)) ->initialReduction : Symbol(initialReduction, Decl(immutable.d.ts, 479, 78)) ->R : Symbol(R, Decl(immutable.d.ts, 479, 16)) ->context : Symbol(context, Decl(immutable.d.ts, 479, 99)) ->R : Symbol(R, Decl(immutable.d.ts, 479, 16)) +>reduceRight : Symbol(Collection.reduceRight, Decl(immutable.ts, 478, 81), Decl(immutable.ts, 479, 118)) +>R : Symbol(R, Decl(immutable.ts, 479, 16)) +>reducer : Symbol(reducer, Decl(immutable.ts, 479, 19)) +>reduction : Symbol(reduction, Decl(immutable.ts, 479, 29)) +>R : Symbol(R, Decl(immutable.ts, 479, 16)) +>value : Symbol(value, Decl(immutable.ts, 479, 42)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 479, 52)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 479, 60)) +>R : Symbol(R, Decl(immutable.ts, 479, 16)) +>initialReduction : Symbol(initialReduction, Decl(immutable.ts, 479, 78)) +>R : Symbol(R, Decl(immutable.ts, 479, 16)) +>context : Symbol(context, Decl(immutable.ts, 479, 99)) +>R : Symbol(R, Decl(immutable.ts, 479, 16)) reduceRight(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; ->reduceRight : Symbol(Collection.reduceRight, Decl(immutable.d.ts, 478, 81), Decl(immutable.d.ts, 479, 118)) ->R : Symbol(R, Decl(immutable.d.ts, 480, 16)) ->reducer : Symbol(reducer, Decl(immutable.d.ts, 480, 19)) ->reduction : Symbol(reduction, Decl(immutable.d.ts, 480, 29)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->R : Symbol(R, Decl(immutable.d.ts, 480, 16)) ->value : Symbol(value, Decl(immutable.d.ts, 480, 46)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 480, 56)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 480, 64)) ->R : Symbol(R, Decl(immutable.d.ts, 480, 16)) ->R : Symbol(R, Decl(immutable.d.ts, 480, 16)) +>reduceRight : Symbol(Collection.reduceRight, Decl(immutable.ts, 478, 81), Decl(immutable.ts, 479, 118)) +>R : Symbol(R, Decl(immutable.ts, 480, 16)) +>reducer : Symbol(reducer, Decl(immutable.ts, 480, 19)) +>reduction : Symbol(reduction, Decl(immutable.ts, 480, 29)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>R : Symbol(R, Decl(immutable.ts, 480, 16)) +>value : Symbol(value, Decl(immutable.ts, 480, 46)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 480, 56)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 480, 64)) +>R : Symbol(R, Decl(immutable.ts, 480, 16)) +>R : Symbol(R, Decl(immutable.ts, 480, 16)) every(predicate: (value: V, key: K, iter: this) => boolean, context?: any): boolean; ->every : Symbol(Collection.every, Decl(immutable.d.ts, 480, 86)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 481, 10)) ->value : Symbol(value, Decl(immutable.d.ts, 481, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 481, 31)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 481, 39)) ->context : Symbol(context, Decl(immutable.d.ts, 481, 63)) +>every : Symbol(Collection.every, Decl(immutable.ts, 480, 86)) +>predicate : Symbol(predicate, Decl(immutable.ts, 481, 10)) +>value : Symbol(value, Decl(immutable.ts, 481, 22)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 481, 31)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 481, 39)) +>context : Symbol(context, Decl(immutable.ts, 481, 63)) some(predicate: (value: V, key: K, iter: this) => boolean, context?: any): boolean; ->some : Symbol(Collection.some, Decl(immutable.d.ts, 481, 88)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 482, 9)) ->value : Symbol(value, Decl(immutable.d.ts, 482, 21)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 482, 30)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 482, 38)) ->context : Symbol(context, Decl(immutable.d.ts, 482, 62)) +>some : Symbol(Collection.some, Decl(immutable.ts, 481, 88)) +>predicate : Symbol(predicate, Decl(immutable.ts, 482, 9)) +>value : Symbol(value, Decl(immutable.ts, 482, 21)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 482, 30)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 482, 38)) +>context : Symbol(context, Decl(immutable.ts, 482, 62)) join(separator?: string): string; ->join : Symbol(Collection.join, Decl(immutable.d.ts, 482, 87)) ->separator : Symbol(separator, Decl(immutable.d.ts, 483, 9)) +>join : Symbol(Collection.join, Decl(immutable.ts, 482, 87)) +>separator : Symbol(separator, Decl(immutable.ts, 483, 9)) isEmpty(): boolean; ->isEmpty : Symbol(Collection.isEmpty, Decl(immutable.d.ts, 483, 37)) +>isEmpty : Symbol(Collection.isEmpty, Decl(immutable.ts, 483, 37)) count(): number; ->count : Symbol(Collection.count, Decl(immutable.d.ts, 484, 23), Decl(immutable.d.ts, 485, 20)) +>count : Symbol(Collection.count, Decl(immutable.ts, 484, 23), Decl(immutable.ts, 485, 20)) count(predicate: (value: V, key: K, iter: this) => boolean, context?: any): number; ->count : Symbol(Collection.count, Decl(immutable.d.ts, 484, 23), Decl(immutable.d.ts, 485, 20)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 486, 10)) ->value : Symbol(value, Decl(immutable.d.ts, 486, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 486, 31)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 486, 39)) ->context : Symbol(context, Decl(immutable.d.ts, 486, 63)) +>count : Symbol(Collection.count, Decl(immutable.ts, 484, 23), Decl(immutable.ts, 485, 20)) +>predicate : Symbol(predicate, Decl(immutable.ts, 486, 10)) +>value : Symbol(value, Decl(immutable.ts, 486, 22)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 486, 31)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 486, 39)) +>context : Symbol(context, Decl(immutable.ts, 486, 63)) countBy(grouper: (value: V, key: K, iter: this) => G, context?: any): Map; ->countBy : Symbol(Collection.countBy, Decl(immutable.d.ts, 486, 87)) ->G : Symbol(G, Decl(immutable.d.ts, 487, 12)) ->grouper : Symbol(grouper, Decl(immutable.d.ts, 487, 15)) ->value : Symbol(value, Decl(immutable.d.ts, 487, 25)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 487, 34)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 487, 42)) ->G : Symbol(G, Decl(immutable.d.ts, 487, 12)) ->context : Symbol(context, Decl(immutable.d.ts, 487, 60)) ->Map : Symbol(Map, Decl(immutable.d.ts, 62, 3), Decl(immutable.d.ts, 66, 3), Decl(immutable.d.ts, 67, 69), Decl(immutable.d.ts, 68, 71), Decl(immutable.d.ts, 69, 66) ... and 2 more) ->G : Symbol(G, Decl(immutable.d.ts, 487, 12)) +>countBy : Symbol(Collection.countBy, Decl(immutable.ts, 486, 87)) +>G : Symbol(G, Decl(immutable.ts, 487, 12)) +>grouper : Symbol(grouper, Decl(immutable.ts, 487, 15)) +>value : Symbol(value, Decl(immutable.ts, 487, 25)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 487, 34)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 487, 42)) +>G : Symbol(G, Decl(immutable.ts, 487, 12)) +>context : Symbol(context, Decl(immutable.ts, 487, 60)) +>Map : Symbol(Map, Decl(immutable.ts, 62, 3), Decl(immutable.ts, 66, 3), Decl(immutable.ts, 67, 69), Decl(immutable.ts, 68, 71), Decl(immutable.ts, 69, 66) ... and 2 more) +>G : Symbol(G, Decl(immutable.ts, 487, 12)) // Search for value find(predicate: (value: V, key: K, iter: this) => boolean, context?: any, notSetValue?: V): V | undefined; ->find : Symbol(Collection.find, Decl(immutable.d.ts, 487, 92)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 489, 9)) ->value : Symbol(value, Decl(immutable.d.ts, 489, 21)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 489, 30)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 489, 38)) ->context : Symbol(context, Decl(immutable.d.ts, 489, 62)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 489, 77)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>find : Symbol(Collection.find, Decl(immutable.ts, 487, 92)) +>predicate : Symbol(predicate, Decl(immutable.ts, 489, 9)) +>value : Symbol(value, Decl(immutable.ts, 489, 21)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 489, 30)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 489, 38)) +>context : Symbol(context, Decl(immutable.ts, 489, 62)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 489, 77)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) findLast(predicate: (value: V, key: K, iter: this) => boolean, context?: any, notSetValue?: V): V | undefined; ->findLast : Symbol(Collection.findLast, Decl(immutable.d.ts, 489, 110)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 490, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 490, 25)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 490, 34)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 490, 42)) ->context : Symbol(context, Decl(immutable.d.ts, 490, 66)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 490, 81)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>findLast : Symbol(Collection.findLast, Decl(immutable.ts, 489, 110)) +>predicate : Symbol(predicate, Decl(immutable.ts, 490, 13)) +>value : Symbol(value, Decl(immutable.ts, 490, 25)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 490, 34)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 490, 42)) +>context : Symbol(context, Decl(immutable.ts, 490, 66)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 490, 81)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) findEntry(predicate: (value: V, key: K, iter: this) => boolean, context?: any, notSetValue?: V): [K, V] | undefined; ->findEntry : Symbol(Collection.findEntry, Decl(immutable.d.ts, 490, 114)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 491, 14)) ->value : Symbol(value, Decl(immutable.d.ts, 491, 26)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 491, 35)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 491, 43)) ->context : Symbol(context, Decl(immutable.d.ts, 491, 67)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 491, 82)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>findEntry : Symbol(Collection.findEntry, Decl(immutable.ts, 490, 114)) +>predicate : Symbol(predicate, Decl(immutable.ts, 491, 14)) +>value : Symbol(value, Decl(immutable.ts, 491, 26)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 491, 35)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 491, 43)) +>context : Symbol(context, Decl(immutable.ts, 491, 67)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 491, 82)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) findLastEntry(predicate: (value: V, key: K, iter: this) => boolean, context?: any, notSetValue?: V): [K, V] | undefined; ->findLastEntry : Symbol(Collection.findLastEntry, Decl(immutable.d.ts, 491, 120)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 492, 18)) ->value : Symbol(value, Decl(immutable.d.ts, 492, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 492, 39)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 492, 47)) ->context : Symbol(context, Decl(immutable.d.ts, 492, 71)) ->notSetValue : Symbol(notSetValue, Decl(immutable.d.ts, 492, 86)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>findLastEntry : Symbol(Collection.findLastEntry, Decl(immutable.ts, 491, 120)) +>predicate : Symbol(predicate, Decl(immutable.ts, 492, 18)) +>value : Symbol(value, Decl(immutable.ts, 492, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 492, 39)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 492, 47)) +>context : Symbol(context, Decl(immutable.ts, 492, 71)) +>notSetValue : Symbol(notSetValue, Decl(immutable.ts, 492, 86)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) findKey(predicate: (value: V, key: K, iter: this) => boolean, context?: any): K | undefined; ->findKey : Symbol(Collection.findKey, Decl(immutable.d.ts, 492, 124)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 493, 12)) ->value : Symbol(value, Decl(immutable.d.ts, 493, 24)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 493, 33)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 493, 41)) ->context : Symbol(context, Decl(immutable.d.ts, 493, 65)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) +>findKey : Symbol(Collection.findKey, Decl(immutable.ts, 492, 124)) +>predicate : Symbol(predicate, Decl(immutable.ts, 493, 12)) +>value : Symbol(value, Decl(immutable.ts, 493, 24)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 493, 33)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 493, 41)) +>context : Symbol(context, Decl(immutable.ts, 493, 65)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) findLastKey(predicate: (value: V, key: K, iter: this) => boolean, context?: any): K | undefined; ->findLastKey : Symbol(Collection.findLastKey, Decl(immutable.d.ts, 493, 96)) ->predicate : Symbol(predicate, Decl(immutable.d.ts, 494, 16)) ->value : Symbol(value, Decl(immutable.d.ts, 494, 28)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 494, 37)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 494, 45)) ->context : Symbol(context, Decl(immutable.d.ts, 494, 69)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) +>findLastKey : Symbol(Collection.findLastKey, Decl(immutable.ts, 493, 96)) +>predicate : Symbol(predicate, Decl(immutable.ts, 494, 16)) +>value : Symbol(value, Decl(immutable.ts, 494, 28)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 494, 37)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 494, 45)) +>context : Symbol(context, Decl(immutable.ts, 494, 69)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) keyOf(searchValue: V): K | undefined; ->keyOf : Symbol(Collection.keyOf, Decl(immutable.d.ts, 494, 100)) ->searchValue : Symbol(searchValue, Decl(immutable.d.ts, 495, 10)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) +>keyOf : Symbol(Collection.keyOf, Decl(immutable.ts, 494, 100)) +>searchValue : Symbol(searchValue, Decl(immutable.ts, 495, 10)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) lastKeyOf(searchValue: V): K | undefined; ->lastKeyOf : Symbol(Collection.lastKeyOf, Decl(immutable.d.ts, 495, 41)) ->searchValue : Symbol(searchValue, Decl(immutable.d.ts, 496, 14)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) +>lastKeyOf : Symbol(Collection.lastKeyOf, Decl(immutable.ts, 495, 41)) +>searchValue : Symbol(searchValue, Decl(immutable.ts, 496, 14)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) max(comparator?: (valueA: V, valueB: V) => number): V | undefined; ->max : Symbol(Collection.max, Decl(immutable.d.ts, 496, 45)) ->comparator : Symbol(comparator, Decl(immutable.d.ts, 497, 8)) ->valueA : Symbol(valueA, Decl(immutable.d.ts, 497, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->valueB : Symbol(valueB, Decl(immutable.d.ts, 497, 32)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>max : Symbol(Collection.max, Decl(immutable.ts, 496, 45)) +>comparator : Symbol(comparator, Decl(immutable.ts, 497, 8)) +>valueA : Symbol(valueA, Decl(immutable.ts, 497, 22)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>valueB : Symbol(valueB, Decl(immutable.ts, 497, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) maxBy(comparatorValueMapper: (value: V, key: K, iter: this) => C, comparator?: (valueA: C, valueB: C) => number): V | undefined; ->maxBy : Symbol(Collection.maxBy, Decl(immutable.d.ts, 497, 70)) ->C : Symbol(C, Decl(immutable.d.ts, 498, 10)) ->comparatorValueMapper : Symbol(comparatorValueMapper, Decl(immutable.d.ts, 498, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 498, 37)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 498, 46)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 498, 54)) ->C : Symbol(C, Decl(immutable.d.ts, 498, 10)) ->comparator : Symbol(comparator, Decl(immutable.d.ts, 498, 72)) ->valueA : Symbol(valueA, Decl(immutable.d.ts, 498, 87)) ->C : Symbol(C, Decl(immutable.d.ts, 498, 10)) ->valueB : Symbol(valueB, Decl(immutable.d.ts, 498, 97)) ->C : Symbol(C, Decl(immutable.d.ts, 498, 10)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>maxBy : Symbol(Collection.maxBy, Decl(immutable.ts, 497, 70)) +>C : Symbol(C, Decl(immutable.ts, 498, 10)) +>comparatorValueMapper : Symbol(comparatorValueMapper, Decl(immutable.ts, 498, 13)) +>value : Symbol(value, Decl(immutable.ts, 498, 37)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 498, 46)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 498, 54)) +>C : Symbol(C, Decl(immutable.ts, 498, 10)) +>comparator : Symbol(comparator, Decl(immutable.ts, 498, 72)) +>valueA : Symbol(valueA, Decl(immutable.ts, 498, 87)) +>C : Symbol(C, Decl(immutable.ts, 498, 10)) +>valueB : Symbol(valueB, Decl(immutable.ts, 498, 97)) +>C : Symbol(C, Decl(immutable.ts, 498, 10)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) min(comparator?: (valueA: V, valueB: V) => number): V | undefined; ->min : Symbol(Collection.min, Decl(immutable.d.ts, 498, 135)) ->comparator : Symbol(comparator, Decl(immutable.d.ts, 499, 8)) ->valueA : Symbol(valueA, Decl(immutable.d.ts, 499, 22)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->valueB : Symbol(valueB, Decl(immutable.d.ts, 499, 32)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>min : Symbol(Collection.min, Decl(immutable.ts, 498, 135)) +>comparator : Symbol(comparator, Decl(immutable.ts, 499, 8)) +>valueA : Symbol(valueA, Decl(immutable.ts, 499, 22)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>valueB : Symbol(valueB, Decl(immutable.ts, 499, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) minBy(comparatorValueMapper: (value: V, key: K, iter: this) => C, comparator?: (valueA: C, valueB: C) => number): V | undefined; ->minBy : Symbol(Collection.minBy, Decl(immutable.d.ts, 499, 70)) ->C : Symbol(C, Decl(immutable.d.ts, 500, 10)) ->comparatorValueMapper : Symbol(comparatorValueMapper, Decl(immutable.d.ts, 500, 13)) ->value : Symbol(value, Decl(immutable.d.ts, 500, 37)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) ->key : Symbol(key, Decl(immutable.d.ts, 500, 46)) ->K : Symbol(K, Decl(immutable.d.ts, 406, 30)) ->iter : Symbol(iter, Decl(immutable.d.ts, 500, 54)) ->C : Symbol(C, Decl(immutable.d.ts, 500, 10)) ->comparator : Symbol(comparator, Decl(immutable.d.ts, 500, 72)) ->valueA : Symbol(valueA, Decl(immutable.d.ts, 500, 87)) ->C : Symbol(C, Decl(immutable.d.ts, 500, 10)) ->valueB : Symbol(valueB, Decl(immutable.d.ts, 500, 97)) ->C : Symbol(C, Decl(immutable.d.ts, 500, 10)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>minBy : Symbol(Collection.minBy, Decl(immutable.ts, 499, 70)) +>C : Symbol(C, Decl(immutable.ts, 500, 10)) +>comparatorValueMapper : Symbol(comparatorValueMapper, Decl(immutable.ts, 500, 13)) +>value : Symbol(value, Decl(immutable.ts, 500, 37)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) +>key : Symbol(key, Decl(immutable.ts, 500, 46)) +>K : Symbol(K, Decl(immutable.ts, 406, 30)) +>iter : Symbol(iter, Decl(immutable.ts, 500, 54)) +>C : Symbol(C, Decl(immutable.ts, 500, 10)) +>comparator : Symbol(comparator, Decl(immutable.ts, 500, 72)) +>valueA : Symbol(valueA, Decl(immutable.ts, 500, 87)) +>C : Symbol(C, Decl(immutable.ts, 500, 10)) +>valueB : Symbol(valueB, Decl(immutable.ts, 500, 97)) +>C : Symbol(C, Decl(immutable.ts, 500, 10)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) // Comparison isSubset(iter: Iterable): boolean; ->isSubset : Symbol(Collection.isSubset, Decl(immutable.d.ts, 500, 135)) ->iter : Symbol(iter, Decl(immutable.d.ts, 502, 13)) +>isSubset : Symbol(Collection.isSubset, Decl(immutable.ts, 500, 135)) +>iter : Symbol(iter, Decl(immutable.ts, 502, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) isSuperset(iter: Iterable): boolean; ->isSuperset : Symbol(Collection.isSuperset, Decl(immutable.d.ts, 502, 41)) ->iter : Symbol(iter, Decl(immutable.d.ts, 503, 15)) +>isSuperset : Symbol(Collection.isSuperset, Decl(immutable.ts, 502, 41)) +>iter : Symbol(iter, Decl(immutable.ts, 503, 15)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->V : Symbol(V, Decl(immutable.d.ts, 406, 32)) +>V : Symbol(V, Decl(immutable.ts, 406, 32)) readonly size: number; ->size : Symbol(Collection.size, Decl(immutable.d.ts, 503, 43)) +>size : Symbol(Collection.size, Decl(immutable.ts, 503, 43)) } } declare module "immutable" { export = Immutable ->Immutable : Symbol(Immutable, Decl(immutable.d.ts, 0, 0)) +>Immutable : Symbol(Immutable, Decl(immutable.ts, 0, 0)) } diff --git a/tests/baselines/reference/complexRecursiveCollections.types b/tests/baselines/reference/complexRecursiveCollections.types index 382a2b86e79..e3d4a01196e 100644 --- a/tests/baselines/reference/complexRecursiveCollections.types +++ b/tests/baselines/reference/complexRecursiveCollections.types @@ -1,4 +1,4 @@ -=== tests/cases/compiler/complex.d.ts === +=== tests/cases/compiler/complex.ts === interface Ara { t: T } >Ara : Ara >T : T @@ -156,7 +156,7 @@ interface N2 extends N1 { >N2 : N2 >T : T } -=== tests/cases/compiler/immutable.d.ts === +=== tests/cases/compiler/immutable.ts === // Test that complex recursive collections can pass the `extends` assignability check without // running out of memory. This bug was exposed in Typescript 2.4 when more generic signatures // started being checked. diff --git a/tests/cases/compiler/complexRecursiveCollections.ts b/tests/cases/compiler/complexRecursiveCollections.ts index 68054aac0f9..ed8906ff441 100644 --- a/tests/cases/compiler/complexRecursiveCollections.ts +++ b/tests/cases/compiler/complexRecursiveCollections.ts @@ -1,5 +1,6 @@ +// @skipLibCheck: true // @lib: es6 -// @Filename: complex.d.ts +// @Filename: complex.ts interface Ara { t: T } interface Collection { map(mapper: (value: V, key: K, iter: this) => M): Collection; @@ -20,7 +21,7 @@ interface N2 extends N1 { flatMap(mapper: (value: T, key: void, iter: this) => Ara, context?: any): N2; toSeq(): N2; } -// @Filename: immutable.d.ts +// @Filename: immutable.ts // Test that complex recursive collections can pass the `extends` assignability check without // running out of memory. This bug was exposed in Typescript 2.4 when more generic signatures // started being checked. diff --git a/tests/cases/conformance/jsx/checkJsxChildrenProperty1.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty1.tsx index 70b58c03f6a..09c003c376c 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty1.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty1.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/checkJsxChildrenProperty13.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty13.tsx index 1584bf43159..0c2d2507864 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty13.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty13.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/checkJsxChildrenProperty2.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty2.tsx index 65bc0f50b12..632b9d5d849 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty2.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty2.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/checkJsxChildrenProperty4.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty4.tsx index 34877f2000c..277f2fb55c2 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty4.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty4.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/checkJsxChildrenProperty6.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty6.tsx index c7c709dd369..40801539f54 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty6.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty6.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/checkJsxChildrenProperty7.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty7.tsx index 82297737a11..0a5d120dd19 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty7.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty7.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/checkJsxChildrenProperty8.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty8.tsx index 44e9f7e0652..c9c5d70ae37 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty8.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty8.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/checkJsxChildrenProperty9.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty9.tsx index 5453262b7d4..7d3d65fbc6f 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty9.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty9.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/commentEmittingInPreserveJsx1.tsx b/tests/cases/conformance/jsx/commentEmittingInPreserveJsx1.tsx index 323cd029189..ebdb36aed15 100644 --- a/tests/cases/conformance/jsx/commentEmittingInPreserveJsx1.tsx +++ b/tests/cases/conformance/jsx/commentEmittingInPreserveJsx1.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution15.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution15.tsx index ce2e12fd2bb..01dedf4711e 100644 --- a/tests/cases/conformance/jsx/tsxAttributeResolution15.tsx +++ b/tests/cases/conformance/jsx/tsxAttributeResolution15.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution16.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution16.tsx index 811a1b47174..15e8089a5ae 100644 --- a/tests/cases/conformance/jsx/tsxAttributeResolution16.tsx +++ b/tests/cases/conformance/jsx/tsxAttributeResolution16.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxDefaultAttributesResolution1.tsx b/tests/cases/conformance/jsx/tsxDefaultAttributesResolution1.tsx index 03314b400ee..b80252bee1b 100644 --- a/tests/cases/conformance/jsx/tsxDefaultAttributesResolution1.tsx +++ b/tests/cases/conformance/jsx/tsxDefaultAttributesResolution1.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxDefaultAttributesResolution2.tsx b/tests/cases/conformance/jsx/tsxDefaultAttributesResolution2.tsx index b00655b5a57..27b1e24e23f 100644 --- a/tests/cases/conformance/jsx/tsxDefaultAttributesResolution2.tsx +++ b/tests/cases/conformance/jsx/tsxDefaultAttributesResolution2.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxDefaultAttributesResolution3.tsx b/tests/cases/conformance/jsx/tsxDefaultAttributesResolution3.tsx index 303e6ef891d..981cdabf464 100644 --- a/tests/cases/conformance/jsx/tsxDefaultAttributesResolution3.tsx +++ b/tests/cases/conformance/jsx/tsxDefaultAttributesResolution3.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxGenericAttributesType1.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType1.tsx index e6b7fc18ef7..ebb80771856 100644 --- a/tests/cases/conformance/jsx/tsxGenericAttributesType1.tsx +++ b/tests/cases/conformance/jsx/tsxGenericAttributesType1.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxGenericAttributesType2.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType2.tsx index 48acd55546f..0b226f9cf90 100644 --- a/tests/cases/conformance/jsx/tsxGenericAttributesType2.tsx +++ b/tests/cases/conformance/jsx/tsxGenericAttributesType2.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxGenericAttributesType3.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType3.tsx index b683c5e7970..28364b93afc 100644 --- a/tests/cases/conformance/jsx/tsxGenericAttributesType3.tsx +++ b/tests/cases/conformance/jsx/tsxGenericAttributesType3.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxGenericAttributesType5.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType5.tsx index d0215da7397..ba8d9a284ca 100644 --- a/tests/cases/conformance/jsx/tsxGenericAttributesType5.tsx +++ b/tests/cases/conformance/jsx/tsxGenericAttributesType5.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxGenericAttributesType6.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType6.tsx index d70df8a0cf7..22634ae9f7d 100644 --- a/tests/cases/conformance/jsx/tsxGenericAttributesType6.tsx +++ b/tests/cases/conformance/jsx/tsxGenericAttributesType6.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxGenericAttributesType7.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType7.tsx index 3044fda23df..07c6f05da1c 100644 --- a/tests/cases/conformance/jsx/tsxGenericAttributesType7.tsx +++ b/tests/cases/conformance/jsx/tsxGenericAttributesType7.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxGenericAttributesType8.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType8.tsx index b1d3a7445c8..77d391f7f39 100644 --- a/tests/cases/conformance/jsx/tsxGenericAttributesType8.tsx +++ b/tests/cases/conformance/jsx/tsxGenericAttributesType8.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxGenericAttributesType9.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType9.tsx index 32a1af66f84..5a3f2b19845 100644 --- a/tests/cases/conformance/jsx/tsxGenericAttributesType9.tsx +++ b/tests/cases/conformance/jsx/tsxGenericAttributesType9.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter1.tsx b/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter1.tsx index 5a8434dfe64..9d9ae5442cd 100644 --- a/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter1.tsx +++ b/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter1.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter2.tsx b/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter2.tsx index 2aa4afc2e2e..84c4ffcef45 100644 --- a/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter2.tsx +++ b/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter2.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter3.tsx b/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter3.tsx index e4a045f1362..abae7e36853 100644 --- a/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter3.tsx +++ b/tests/cases/conformance/jsx/tsxReactComponentWithDefaultTypeParameter3.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution1.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution1.tsx index a14a7ffe59c..dfaaa8b3b72 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution1.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution1.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution10.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution10.tsx index 6410f075ae9..733731731e4 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution10.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution10.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution11.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution11.tsx index c8008623441..458cac5bc98 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution11.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution11.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution12.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution12.tsx index 457a3f29810..4e0baa8677b 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution12.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution12.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution13.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution13.tsx index b665654514c..a9ebb4caba4 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution13.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution13.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution14.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution14.tsx index b9edcc8ab75..5bfe228d10a 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution14.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution14.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution15.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution15.tsx index 5ede01c0eab..2ee07507c08 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution15.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution15.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution16.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution16.tsx index 98616661857..d197e29fed3 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution16.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution16.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution2.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution2.tsx index 7ec1d871189..f32b367b718 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution2.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution2.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution4.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution4.tsx index 8afec4b69c8..3d39a1a7cc9 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution4.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution4.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution5.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution5.tsx index 22045c81451..dcea930fa25 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution5.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution5.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution6.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution6.tsx index 35a190e10cc..5c7d9448d12 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution6.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution6.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution7.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution7.tsx index 55e3222c022..34cd8254b7a 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution7.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution7.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution8.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution8.tsx index 937678605d6..04e61e32eb9 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution8.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution8.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution9.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution9.tsx index 9f2a63a56b6..c14003774c2 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution9.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution9.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload3.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload3.tsx index e4e8fe9f096..1c2afd82533 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload3.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload3.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts interface Context { diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload4.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload4.tsx index b96073b4cc0..93ac29e4d84 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload4.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload4.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react') diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload5.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload5.tsx index 34be082b3c8..b32393c44ce 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload5.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload5.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react') diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentWithDefaultTypeParameter1.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentWithDefaultTypeParameter1.tsx index f1a0fa20e0e..d9256ee6607 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentWithDefaultTypeParameter1.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentWithDefaultTypeParameter1.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react') diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentWithDefaultTypeParameter2.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentWithDefaultTypeParameter2.tsx index cfc1fbb5794..2117aedfac1 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentWithDefaultTypeParameter2.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentWithDefaultTypeParameter2.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react') diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponents2.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponents2.tsx index d2a6586b436..01e848f574e 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponents2.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponents2.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponents3.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponents3.tsx index 48ce5fb5efb..9490e913f92 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponents3.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponents3.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments1.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments1.tsx index f910ef665e6..75b9915853b 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments1.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments1.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react') diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments4.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments4.tsx index 4be582dab5c..6cd88999425 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments4.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments4.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react') diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments5.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments5.tsx index c19bfdf43bd..dcc87018818 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments5.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments5.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react') diff --git a/tests/cases/conformance/jsx/tsxUnionElementType1.tsx b/tests/cases/conformance/jsx/tsxUnionElementType1.tsx index 300f0e95172..91457469a8d 100644 --- a/tests/cases/conformance/jsx/tsxUnionElementType1.tsx +++ b/tests/cases/conformance/jsx/tsxUnionElementType1.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: react // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxUnionElementType2.tsx b/tests/cases/conformance/jsx/tsxUnionElementType2.tsx index 6a9ccd42b2e..ae0c0843b81 100644 --- a/tests/cases/conformance/jsx/tsxUnionElementType2.tsx +++ b/tests/cases/conformance/jsx/tsxUnionElementType2.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: react // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxUnionElementType3.tsx b/tests/cases/conformance/jsx/tsxUnionElementType3.tsx index 5582150bf8c..6e021bc99fa 100644 --- a/tests/cases/conformance/jsx/tsxUnionElementType3.tsx +++ b/tests/cases/conformance/jsx/tsxUnionElementType3.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: react // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxUnionElementType4.tsx b/tests/cases/conformance/jsx/tsxUnionElementType4.tsx index 725f93643c1..e7d7b6ff5ff 100644 --- a/tests/cases/conformance/jsx/tsxUnionElementType4.tsx +++ b/tests/cases/conformance/jsx/tsxUnionElementType4.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: react // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxUnionElementType5.tsx b/tests/cases/conformance/jsx/tsxUnionElementType5.tsx index 9341bc5805a..2f3d96f4ecc 100644 --- a/tests/cases/conformance/jsx/tsxUnionElementType5.tsx +++ b/tests/cases/conformance/jsx/tsxUnionElementType5.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: react // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxUnionElementType6.tsx b/tests/cases/conformance/jsx/tsxUnionElementType6.tsx index 99d7b980894..e4d2514dbd4 100644 --- a/tests/cases/conformance/jsx/tsxUnionElementType6.tsx +++ b/tests/cases/conformance/jsx/tsxUnionElementType6.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: react // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/jsx/tsxUnionTypeComponent2.tsx b/tests/cases/conformance/jsx/tsxUnionTypeComponent2.tsx index dbd14f6c27f..394e5e07d34 100644 --- a/tests/cases/conformance/jsx/tsxUnionTypeComponent2.tsx +++ b/tests/cases/conformance/jsx/tsxUnionTypeComponent2.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: react // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react'); diff --git a/tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes02.tsx b/tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes02.tsx index 1fa798c850f..53171833d9d 100644 --- a/tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes02.tsx +++ b/tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes02.tsx @@ -2,6 +2,7 @@ // @jsx: preserve // @module: amd // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts import React = require('react')