diff --git a/Gulpfile.ts b/Gulpfile.ts index 1b82d24bcf8..24ff1f3f3c9 100644 --- a/Gulpfile.ts +++ b/Gulpfile.ts @@ -394,7 +394,7 @@ gulp.task(generateLocalizedDiagnosticMessagesJs, /*help*/ false, [], () => { .pipe(sourcemaps.init()) .pipe(tsc(settings)) .pipe(sourcemaps.write(".")) - .pipe(gulp.dest(".")); + .pipe(gulp.dest(scriptsDirectory)); }); // Localize diagnostics @@ -1091,7 +1091,7 @@ gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are: const fileMatcher = cmdLineOptions["files"]; const files = fileMatcher ? `src/**/${fileMatcher}` - : "Gulpfile.ts 'scripts/generateLocalizedDiagnosticMessages.ts' scripts/tslint/**/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'"; + : "Gulpfile.ts 'scripts/generateLocalizedDiagnosticMessages.ts' 'scripts/tslint/**/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'"; const cmd = `node node_modules/tslint/bin/tslint ${files} --formatters-dir ./built/local/tslint/formatters --format autolinkableStylish`; console.log("Linting: " + cmd); child_process.execSync(cmd, { stdio: [0, 1, 2] }); diff --git a/Jakefile.js b/Jakefile.js index 0d6474fc571..0b3659e2051 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -129,6 +129,7 @@ var harnessSources = harnessCoreSources.concat([ "textStorage.ts", "moduleResolution.ts", "tsconfigParsing.ts", + "builder.ts", "commandLineParsing.ts", "configurationExtension.ts", "convertCompilerOptionsFromJson.ts", diff --git a/src/compiler/builder.ts b/src/compiler/builder.ts index 38969b85bac..6bb94ea2de7 100644 --- a/src/compiler/builder.ts +++ b/src/compiler/builder.ts @@ -93,12 +93,14 @@ namespace ts { signature: string; } - export function createBuilder( - getCanonicalFileName: (fileName: string) => string, - getEmitOutput: (program: Program, sourceFile: SourceFile, emitOnlyDtsFiles: boolean, isDetailed: boolean) => EmitOutput | EmitOutputDetailed, - computeHash: (data: string) => string, - shouldEmitFile: (sourceFile: SourceFile) => boolean - ): Builder { + export interface BuilderOptions { + getCanonicalFileName: (fileName: string) => string; + getEmitOutput: (program: Program, sourceFile: SourceFile, emitOnlyDtsFiles: boolean, isDetailed: boolean) => EmitOutput | EmitOutputDetailed; + computeHash: (data: string) => string; + shouldEmitFile: (sourceFile: SourceFile) => boolean; + } + + export function createBuilder(options: BuilderOptions): Builder { let isModuleEmit: boolean | undefined; const fileInfos = createMap(); const semanticDiagnosticsPerFile = createMap>(); @@ -181,7 +183,7 @@ namespace ts { ensureProgramGraph(program); const sourceFile = program.getSourceFile(path); - const singleFileResult = sourceFile && shouldEmitFile(sourceFile) ? [sourceFile.fileName] : []; + const singleFileResult = sourceFile && options.shouldEmitFile(sourceFile) ? [sourceFile.fileName] : []; const info = fileInfos.get(path); if (!info || !updateShapeSignature(program, sourceFile, info)) { return singleFileResult; @@ -197,7 +199,7 @@ namespace ts { return { outputFiles: [], emitSkipped: true }; } - return getEmitOutput(program, program.getSourceFileByPath(path), /*emitOnlyDtsFiles*/ false, /*isDetailed*/ false); + return options.getEmitOutput(program, program.getSourceFileByPath(path), /*emitOnlyDtsFiles*/ false, /*isDetailed*/ false); } function enumerateChangedFilesSet( @@ -220,21 +222,21 @@ namespace ts { onChangedFile: (fileName: string, path: Path) => void, onEmitOutput: (emitOutput: EmitOutputDetailed, sourceFile: SourceFile) => void ) { - const seenFiles = createMap(); + const seenFiles = createMap(); enumerateChangedFilesSet(program, onChangedFile, (fileName, sourceFile) => { if (!seenFiles.has(fileName)) { - seenFiles.set(fileName, sourceFile); + seenFiles.set(fileName, true); if (sourceFile) { // Any affected file shouldnt have the cached diagnostics semanticDiagnosticsPerFile.delete(sourceFile.path); - const emitOutput = getEmitOutput(program, sourceFile, emitOnlyDtsFiles, /*isDetailed*/ true) as EmitOutputDetailed; + const emitOutput = options.getEmitOutput(program, sourceFile, emitOnlyDtsFiles, /*isDetailed*/ true) as EmitOutputDetailed; onEmitOutput(emitOutput, sourceFile); // mark all the emitted source files as seen if (emitOutput.emittedSourceFiles) { for (const file of emitOutput.emittedSourceFiles) { - seenFiles.set(file.fileName, file); + seenFiles.set(file.fileName, true); } } } @@ -309,13 +311,13 @@ namespace ts { const prevSignature = info.signature; let latestSignature: string; if (sourceFile.isDeclarationFile) { - latestSignature = computeHash(sourceFile.text); + latestSignature = options.computeHash(sourceFile.text); info.signature = latestSignature; } else { - const emitOutput = getEmitOutput(program, sourceFile, /*emitOnlyDtsFiles*/ true, /*isDetailed*/ false); + const emitOutput = options.getEmitOutput(program, sourceFile, /*emitOnlyDtsFiles*/ true, /*isDetailed*/ false); if (emitOutput.outputFiles && emitOutput.outputFiles.length > 0) { - latestSignature = computeHash(emitOutput.outputFiles[0].text); + latestSignature = options.computeHash(emitOutput.outputFiles[0].text); info.signature = latestSignature; } else { @@ -352,7 +354,7 @@ namespace ts { // Handle triple slash references if (sourceFile.referencedFiles && sourceFile.referencedFiles.length > 0) { for (const referencedFile of sourceFile.referencedFiles) { - const referencedPath = toPath(referencedFile.fileName, sourceFileDirectory, getCanonicalFileName); + const referencedPath = toPath(referencedFile.fileName, sourceFileDirectory, options.getCanonicalFileName); addReferencedFile(referencedPath); } } @@ -365,7 +367,7 @@ namespace ts { } const fileName = resolvedTypeReferenceDirective.resolvedFileName; - const typeFilePath = toPath(fileName, sourceFileDirectory, getCanonicalFileName); + const typeFilePath = toPath(fileName, sourceFileDirectory, options.getCanonicalFileName); addReferencedFile(typeFilePath); }); } @@ -381,18 +383,26 @@ namespace ts { } /** - * Gets all the emittable files from the program + * Gets all the emittable files from the program. + * @param firstSourceFile This one will be emitted first. See https://github.com/Microsoft/TypeScript/issues/16888 */ - function getAllEmittableFiles(program: Program) { + function getAllEmittableFiles(program: Program, firstSourceFile: SourceFile): string[] { const defaultLibraryFileName = getDefaultLibFileName(program.getCompilerOptions()); const sourceFiles = program.getSourceFiles(); const result: string[] = []; + add(firstSourceFile); for (const sourceFile of sourceFiles) { - if (getBaseFileName(sourceFile.fileName) !== defaultLibraryFileName && shouldEmitFile(sourceFile)) { - result.push(sourceFile.fileName); + if (sourceFile !== firstSourceFile) { + add(sourceFile); } } return result; + + function add(sourceFile: SourceFile): void { + if (getBaseFileName(sourceFile.fileName) !== defaultLibraryFileName && options.shouldEmitFile(sourceFile)) { + result.push(sourceFile.fileName); + } + } } function getNonModuleEmitHandler(): EmitHandler { @@ -404,14 +414,14 @@ namespace ts { getFilesAffectedByUpdatedShape }; - function getFilesAffectedByUpdatedShape(program: Program, _sourceFile: SourceFile, singleFileResult: string[]): string[] { + function getFilesAffectedByUpdatedShape(program: Program, sourceFile: SourceFile, singleFileResult: string[]): string[] { const options = program.getCompilerOptions(); // If `--out` or `--outFile` is specified, any new emit will result in re-emitting the entire project, // so returning the file itself is good enough. if (options && (options.out || options.outFile)) { return singleFileResult; } - return getAllEmittableFiles(program); + return getAllEmittableFiles(program, sourceFile); } } @@ -484,11 +494,11 @@ namespace ts { function getFilesAffectedByUpdatedShape(program: Program, sourceFile: SourceFile, singleFileResult: string[]): string[] { if (!isExternalModule(sourceFile) && !containsOnlyAmbientModules(sourceFile)) { - return getAllEmittableFiles(program); + return getAllEmittableFiles(program, sourceFile); } - const options = program.getCompilerOptions(); - if (options && (options.isolatedModules || options.out || options.outFile)) { + const compilerOptions = program.getCompilerOptions(); + if (compilerOptions && (compilerOptions.isolatedModules || compilerOptions.out || compilerOptions.outFile)) { return singleFileResult; } @@ -498,7 +508,7 @@ namespace ts { const seenFileNamesMap = createMap(); const setSeenFileName = (path: Path, sourceFile: SourceFile) => { - seenFileNamesMap.set(path, sourceFile && shouldEmitFile(sourceFile) ? sourceFile.fileName : undefined); + seenFileNamesMap.set(path, sourceFile && options.shouldEmitFile(sourceFile) ? sourceFile.fileName : undefined); }; // Start with the paths this file was referenced by diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6f5cc8e0e5b..e9ed2d889a9 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -13512,13 +13512,25 @@ namespace ts { const binaryExpression = node.parent; const operator = binaryExpression.operatorToken.kind; if (isAssignmentOperator(operator)) { - // Don't do this for special property assignments to avoid circularity - if (getSpecialPropertyAssignmentKind(binaryExpression) !== SpecialPropertyAssignmentKind.None) { - return undefined; - } - - // In an assignment expression, the right operand is contextually typed by the type of the left operand. if (node === binaryExpression.right) { + // Don't do this for special property assignments to avoid circularity + switch (getSpecialPropertyAssignmentKind(binaryExpression)) { + case SpecialPropertyAssignmentKind.None: + break; + case SpecialPropertyAssignmentKind.Property: + // If `binaryExpression.left` was assigned a symbol, then this is a new declaration; otherwise it is an assignment to an existing declaration. + // See `bindStaticPropertyAssignment` in `binder.ts`. + if (!binaryExpression.left.symbol) { + break; + } + // falls through + case SpecialPropertyAssignmentKind.ExportsProperty: + case SpecialPropertyAssignmentKind.ModuleExports: + case SpecialPropertyAssignmentKind.PrototypeProperty: + case SpecialPropertyAssignmentKind.ThisProperty: + return undefined; + } + // In an assignment expression, the right operand is contextually typed by the type of the left operand. return getTypeOfExpression(binaryExpression.left); } } diff --git a/src/compiler/core.ts b/src/compiler/core.ts index c912cfa6b53..45a4a04b6ab 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -247,6 +247,8 @@ namespace ts { } /** Works like Array.prototype.find, returning `undefined` if no element satisfying the predicate is found. */ + export function find(array: ReadonlyArray, predicate: (element: T, index: number) => element is U): U | undefined; + export function find(array: ReadonlyArray, predicate: (element: T, index: number) => boolean): T | undefined; export function find(array: ReadonlyArray, predicate: (element: T, index: number) => boolean): T | undefined { for (let i = 0; i < array.length; i++) { const value = array[i]; diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 9a97e231f65..e8a37fcbdea 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -3785,5 +3785,15 @@ "Extract constant": { "category": "Message", "code": 95006 + }, + + "Extract to {0} in enclosing scope": { + "category": "Message", + "code": 95007 + }, + + "Extract to {0} in {1} scope": { + "category": "Message", + "code": 95008 } } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index bb7de450db6..5aabc4163e0 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -6646,7 +6646,7 @@ namespace ts { function parsePropertyAccessEntityNameExpression() { let node: Identifier | PropertyAccessEntityNameExpression = parseJSDocIdentifierName(/*createIfMissing*/ true); - while (token() === SyntaxKind.DotToken) { + while (parseOptional(SyntaxKind.DotToken)) { const prop: PropertyAccessEntityNameExpression = createNode(SyntaxKind.PropertyAccessExpression, node.pos) as PropertyAccessEntityNameExpression; prop.expression = node; prop.name = parseJSDocIdentifierName(); diff --git a/src/compiler/watch.ts b/src/compiler/watch.ts index 2900737b09f..779efb62c46 100644 --- a/src/compiler/watch.ts +++ b/src/compiler/watch.ts @@ -308,7 +308,7 @@ namespace ts { getCurrentDirectory() ); // There is no extra check needed since we can just rely on the program to decide emit - const builder = createBuilder(getCanonicalFileName, getFileEmitOutput, computeHash, _sourceFile => true); + const builder = createBuilder({ getCanonicalFileName, getEmitOutput: getFileEmitOutput, computeHash, shouldEmitFile: () => true }); synchronizeProgram(); diff --git a/src/harness/parallel/host.ts b/src/harness/parallel/host.ts index 36fb3cd08d1..2aaa4f78728 100644 --- a/src/harness/parallel/host.ts +++ b/src/harness/parallel/host.ts @@ -312,6 +312,9 @@ namespace Harness.Parallel.Host { function makeMochaTest(test: ErrorInfo) { return { fullTitle: () => { + return test.name.join(" "); + }, + titlePath: () => { return test.name; }, err: { diff --git a/src/harness/parallel/shared.ts b/src/harness/parallel/shared.ts index 280420dcdba..85d885c14a1 100644 --- a/src/harness/parallel/shared.ts +++ b/src/harness/parallel/shared.ts @@ -6,8 +6,8 @@ namespace Harness.Parallel { export type ParallelCloseMessage = { type: "close" } | never; export type ParallelHostMessage = ParallelTestMessage | ParallelCloseMessage | ParallelBatchMessage; - export type ParallelErrorMessage = { type: "error", payload: { error: string, stack: string, name?: string } } | never; - export type ErrorInfo = ParallelErrorMessage["payload"] & { name: string }; + export type ParallelErrorMessage = { type: "error", payload: { error: string, stack: string, name?: string[] } } | never; + export type ErrorInfo = ParallelErrorMessage["payload"] & { name: string[] }; export type ParallelResultMessage = { type: "result", payload: { passing: number, errors: ErrorInfo[], duration: number, runner: TestRunnerKind, file: string } } | never; export type ParallelBatchProgressMessage = { type: "progress", payload: ParallelResultMessage["payload"] } | never; export type ParallelClientMessage = ParallelErrorMessage | ParallelResultMessage | ParallelBatchProgressMessage; diff --git a/src/harness/parallel/worker.ts b/src/harness/parallel/worker.ts index 1a3901b4fc4..7e95831535a 100644 --- a/src/harness/parallel/worker.ts +++ b/src/harness/parallel/worker.ts @@ -12,6 +12,11 @@ namespace Harness.Parallel.Worker { testList.length = 0; } reportedUnitTests = true; + if (testList.length) { + // Execute unit tests + testList.forEach(({ name, callback, kind }) => executeCallback(name, callback, kind)); + testList.length = 0; + } const start = +(new Date()); runner.initializeTests(); testList.forEach(({ name, callback, kind }) => executeCallback(name, callback, kind)); @@ -57,14 +62,14 @@ namespace Harness.Parallel.Worker { callback.call(fakeContext); } catch (e) { - errors.push({ error: `Error executing suite: ${e.message}`, stack: e.stack, name: namestack.join(" ") }); + errors.push({ error: `Error executing suite: ${e.message}`, stack: e.stack, name: [...namestack] }); return cleanup(); } try { beforeFunc && beforeFunc(); } catch (e) { - errors.push({ error: `Error executing before function: ${e.message}`, stack: e.stack, name: namestack.join(" ") }); + errors.push({ error: `Error executing before function: ${e.message}`, stack: e.stack, name: [...namestack] }); return cleanup(); } finally { @@ -76,7 +81,7 @@ namespace Harness.Parallel.Worker { afterFunc && afterFunc(); } catch (e) { - errors.push({ error: `Error executing after function: ${e.message}`, stack: e.stack, name: namestack.join(" ") }); + errors.push({ error: `Error executing after function: ${e.message}`, stack: e.stack, name: [...namestack] }); } finally { afterFunc = undefined; @@ -107,13 +112,12 @@ namespace Harness.Parallel.Worker { slow() { return this; }, }; namestack.push(name); - name = namestack.join(" "); if (beforeEachFunc) { try { beforeEachFunc(); } catch (error) { - errors.push({ error: error.message, stack: error.stack, name }); + errors.push({ error: error.message, stack: error.stack, name: [...namestack] }); namestack.pop(); return; } @@ -124,7 +128,7 @@ namespace Harness.Parallel.Worker { callback.call(fakeContext); } catch (error) { - errors.push({ error: error.message, stack: error.stack, name }); + errors.push({ error: error.message, stack: error.stack, name: [...namestack] }); return; } finally { @@ -141,7 +145,7 @@ namespace Harness.Parallel.Worker { throw new Error(`done() callback called multiple times; ensure it is only called once.`); } if (err) { - errors.push({ error: err.toString(), stack: "", name }); + errors.push({ error: err.toString(), stack: "", name: [...namestack] }); } else { passing++; @@ -150,14 +154,14 @@ namespace Harness.Parallel.Worker { }); } catch (error) { - errors.push({ error: error.message, stack: error.stack, name }); + errors.push({ error: error.message, stack: error.stack, name: [...namestack] }); return; } finally { namestack.pop(); } if (!completed) { - errors.push({ error: "Test completes asynchronously, which is unsupported by the parallel harness", stack: "", name }); + errors.push({ error: "Test completes asynchronously, which is unsupported by the parallel harness", stack: "", name: [...namestack] }); } } } @@ -204,7 +208,7 @@ namespace Harness.Parallel.Worker { } }); process.on("uncaughtException", error => { - const message: ParallelErrorMessage = { type: "error", payload: { error: error.message, stack: error.stack, name: namestack.join(" ") } }; + const message: ParallelErrorMessage = { type: "error", payload: { error: error.message, stack: error.stack, name: [...namestack] } }; try { process.send(message); } diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json index 509fe550c07..a0c141f4f17 100644 --- a/src/harness/tsconfig.json +++ b/src/harness/tsconfig.json @@ -116,6 +116,7 @@ "./unittests/reuseProgramStructure.ts", "./unittests/moduleResolution.ts", "./unittests/tsconfigParsing.ts", + "./unittests/builder.ts", "./unittests/commandLineParsing.ts", "./unittests/configurationExtension.ts", "./unittests/convertCompilerOptionsFromJson.ts", diff --git a/src/harness/unittests/builder.ts b/src/harness/unittests/builder.ts new file mode 100644 index 00000000000..edd471e9ebe --- /dev/null +++ b/src/harness/unittests/builder.ts @@ -0,0 +1,73 @@ +/// + +namespace ts { + describe("builder", () => { + it("emits dependent files", () => { + const files: NamedSourceText[] = [ + { name: "/a.ts", text: SourceText.New("", 'import { b } from "./b";', "") }, + { name: "/b.ts", text: SourceText.New("", ' import { c } from "./c";', "export const b = c;") }, + { name: "/c.ts", text: SourceText.New("", "", "export const c = 0;") }, + ]; + + let program = newProgram(files, ["/a.ts"], {}); + const assertChanges = makeAssertChanges(() => program); + + assertChanges(["/c.js", "/b.js", "/a.js"]); + + program = updateProgramFile(program, "/a.ts", "//comment"); + assertChanges(["/a.js"]); + + program = updateProgramFile(program, "/b.ts", "export const b = c + 1;"); + assertChanges(["/b.js", "/a.js"]); + + program = updateProgramFile(program, "/c.ts", "export const c = 1;"); + assertChanges(["/c.js", "/b.js"]); + }); + + it("if emitting all files, emits the changed file first", () => { + const files: NamedSourceText[] = [ + { name: "/a.ts", text: SourceText.New("", "", "namespace A { export const x = 0; }") }, + { name: "/b.ts", text: SourceText.New("", "", "namespace B { export const x = 0; }") }, + ]; + + let program = newProgram(files, ["/a.ts", "/b.ts"], {}); + const assertChanges = makeAssertChanges(() => program); + + assertChanges(["/a.js", "/b.js"]); + + program = updateProgramFile(program, "/a.ts", "namespace A { export const x = 1; }"); + assertChanges(["/a.js", "/b.js"]); + + program = updateProgramFile(program, "/b.ts", "namespace B { export const x = 1; }"); + assertChanges(["/b.js", "/a.js"]); + }); + }); + + function makeAssertChanges(getProgram: () => Program): (fileNames: ReadonlyArray) => void { + const builder = createBuilder({ + getCanonicalFileName: identity, + getEmitOutput: getFileEmitOutput, + computeHash: identity, + shouldEmitFile: returnTrue, + }); + return fileNames => { + const program = getProgram(); + builder.updateProgram(program); + const changedFiles = builder.emitChangedFiles(program); + assert.deepEqual(changedFileNames(changedFiles), fileNames); + }; + } + + function updateProgramFile(program: ProgramWithSourceTexts, fileName: string, fileContent: string): ProgramWithSourceTexts { + return updateProgram(program, program.getRootFileNames(), program.getCompilerOptions(), files => { + updateProgramText(files, fileName, fileContent); + }); + } + + function changedFileNames(changedFiles: ReadonlyArray): string[] { + return changedFiles.map(f => { + assert.lengthOf(f.outputFiles, 1); + return f.outputFiles[0].name; + }); + } +} diff --git a/src/harness/unittests/extractConstants.ts b/src/harness/unittests/extractConstants.ts index 28109a6fa4d..c5ddc18fea4 100644 --- a/src/harness/unittests/extractConstants.ts +++ b/src/harness/unittests/extractConstants.ts @@ -33,6 +33,20 @@ namespace ts { testExtractConstant("extractConstant_ExpressionStatementExpression", `[#|"hello"|];`); + testExtractConstant("extractConstant_ExpressionStatementInNestedScope", ` +let i = 0; +function F() { + [#|i++|]; +} + `); + + testExtractConstant("extractConstant_ExpressionStatementConsumesLocal", ` +function F() { + let i = 0; + [#|i++|]; +} + `); + testExtractConstant("extractConstant_BlockScopes_NoDependencies", `for (let i = 0; i < 10; i++) { for (let j = 0; j < 10; j++) { @@ -200,9 +214,29 @@ const x = [#|2 + 1|]; /* About x */ const x = [#|2 + 1|]; `); + + testExtractConstant("extractConstant_ArrowFunction_Block", ` +const f = () => { + return [#|2 + 1|]; +};`); + + testExtractConstant("extractConstant_ArrowFunction_Expression", + `const f = () => [#|2 + 1|];`); + + testExtractConstantFailed("extractConstant_Void", ` +function f(): void { } +[#|f();|]`); + + testExtractConstantFailed("extractConstant_Never", ` +function f(): never { } +[#|f();|]`); }); function testExtractConstant(caption: string, text: string) { testExtractSymbol(caption, text, "extractConstant", Diagnostics.Extract_constant); } + + function testExtractConstantFailed(caption: string, text: string) { + testExtractSymbolFailed(caption, text, Diagnostics.Extract_constant); + } } diff --git a/src/harness/unittests/extractTestHelpers.ts b/src/harness/unittests/extractTestHelpers.ts index 0d739919e1f..1b51cdadc27 100644 --- a/src/harness/unittests/extractTestHelpers.ts +++ b/src/harness/unittests/extractTestHelpers.ts @@ -135,7 +135,7 @@ namespace ts { Harness.Baseline.runBaseline(`${baselineFolder}/${caption}${extension}`, () => { const data: string[] = []; data.push(`// ==ORIGINAL==`); - data.push(sourceFile.text); + data.push(text.replace("[#|", "/*[#|*/").replace("|]", "/*|]*/")); for (const action of actions) { const { renameLocation, edits } = refactor.extractSymbol.getEditsForAction(context, action.name); assert.lengthOf(edits, 1); diff --git a/src/harness/unittests/reuseProgramStructure.ts b/src/harness/unittests/reuseProgramStructure.ts index 5c2b9edd9d0..e0c0e6f80a8 100644 --- a/src/harness/unittests/reuseProgramStructure.ts +++ b/src/harness/unittests/reuseProgramStructure.ts @@ -15,12 +15,12 @@ namespace ts { sourceText?: SourceText; } - interface NamedSourceText { + export interface NamedSourceText { name: string; text: SourceText; } - interface ProgramWithSourceTexts extends Program { + export interface ProgramWithSourceTexts extends Program { sourceTexts?: ReadonlyArray; host: TestCompilerHost; } @@ -29,7 +29,7 @@ namespace ts { getTrace(): string[]; } - class SourceText implements IScriptSnapshot { + export class SourceText implements IScriptSnapshot { private fullText: string; constructor(private references: string, @@ -103,10 +103,11 @@ namespace ts { function createSourceFileWithText(fileName: string, sourceText: SourceText, target: ScriptTarget) { const file = createSourceFile(fileName, sourceText.getFullText(), target); file.sourceText = sourceText; + file.version = "" + sourceText.getVersion(); return file; } - function createTestCompilerHost(texts: ReadonlyArray, target: ScriptTarget, oldProgram?: ProgramWithSourceTexts): TestCompilerHost { + export function createTestCompilerHost(texts: ReadonlyArray, target: ScriptTarget, oldProgram?: ProgramWithSourceTexts): TestCompilerHost { const files = arrayToMap(texts, t => t.name, t => { if (oldProgram) { let oldFile = oldProgram.getSourceFile(t.name); @@ -154,7 +155,7 @@ namespace ts { }; } - function newProgram(texts: NamedSourceText[], rootNames: string[], options: CompilerOptions): ProgramWithSourceTexts { + export function newProgram(texts: NamedSourceText[], rootNames: string[], options: CompilerOptions): ProgramWithSourceTexts { const host = createTestCompilerHost(texts, options.target); const program = createProgram(rootNames, options, host); program.sourceTexts = texts; @@ -162,7 +163,7 @@ namespace ts { return program; } - function updateProgram(oldProgram: ProgramWithSourceTexts, rootNames: ReadonlyArray, options: CompilerOptions, updater: (files: NamedSourceText[]) => void, newTexts?: NamedSourceText[]) { + export function updateProgram(oldProgram: ProgramWithSourceTexts, rootNames: ReadonlyArray, options: CompilerOptions, updater: (files: NamedSourceText[]) => void, newTexts?: NamedSourceText[]) { if (!newTexts) { newTexts = (oldProgram).sourceTexts.slice(0); } @@ -174,7 +175,7 @@ namespace ts { return program; } - function updateProgramText(files: ReadonlyArray, fileName: string, newProgramText: string) { + export function updateProgramText(files: ReadonlyArray, fileName: string, newProgramText: string) { const file = find(files, f => f.name === fileName)!; file.text = file.text.updateProgram(newProgramText); } diff --git a/src/server/project.ts b/src/server/project.ts index 27f0744537a..655f3ed0cfc 100644 --- a/src/server/project.ts +++ b/src/server/project.ts @@ -167,6 +167,8 @@ namespace ts.server { private typingFiles: SortedReadonlyArray; + private readonly cancellationToken: ThrottledCancellationToken; + public isNonTsProject() { this.updateGraph(); return allFilesAreJsOrDts(this); @@ -206,6 +208,7 @@ namespace ts.server { /*@internal*/public directoryStructureHost: DirectoryStructureHost, rootDirectoryForResolution: string | undefined) { + this.cancellationToken = new ThrottledCancellationToken(this.projectService.cancellationToken, this.projectService.throttleWaitMilliseconds); if (!this.compilerOptions) { this.compilerOptions = getDefaultCompilerOptions(); this.compilerOptions.allowNonTsExtensions = true; @@ -294,7 +297,7 @@ namespace ts.server { } getCancellationToken() { - return this.projectService.cancellationToken; + return this.cancellationToken; } getCurrentDirectory(): string { @@ -417,12 +420,15 @@ namespace ts.server { private ensureBuilder() { if (!this.builder) { - this.builder = createBuilder( - this.projectService.toCanonicalFileName, - (_program, sourceFile, emitOnlyDts, isDetailed) => this.getFileEmitOutput(sourceFile, emitOnlyDts, isDetailed), - data => this.projectService.host.createHash(data), - sourceFile => !this.projectService.getScriptInfoForPath(sourceFile.path).isDynamicOrHasMixedContent() - ); + this.builder = createBuilder({ + getCanonicalFileName: this.projectService.toCanonicalFileName, + getEmitOutput: (_program, sourceFile, emitOnlyDts, isDetailed) => + this.getFileEmitOutput(sourceFile, emitOnlyDts, isDetailed), + computeHash: data => + this.projectService.host.createHash(data), + shouldEmitFile: sourceFile => + !this.projectService.getScriptInfoForPath(sourceFile.path).isDynamicOrHasMixedContent() + }); } } diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts index ca4bb861c7d..4f11e33c638 100644 --- a/src/services/documentHighlights.ts +++ b/src/services/documentHighlights.ts @@ -265,104 +265,83 @@ namespace ts.DocumentHighlights { } function getModifierOccurrences(modifier: SyntaxKind, declaration: Node): Node[] { - const container = declaration.parent; - // Make sure we only highlight the keyword when it makes sense to do so. - if (isAccessibilityModifier(modifier)) { - if (!(container.kind === SyntaxKind.ClassDeclaration || - container.kind === SyntaxKind.ClassExpression || - (declaration.kind === SyntaxKind.Parameter && hasKind(container, SyntaxKind.Constructor)))) { - return undefined; - } - } - else if (modifier === SyntaxKind.StaticKeyword) { - if (!(container.kind === SyntaxKind.ClassDeclaration || container.kind === SyntaxKind.ClassExpression)) { - return undefined; - } - } - else if (modifier === SyntaxKind.ExportKeyword || modifier === SyntaxKind.DeclareKeyword) { - if (!(container.kind === SyntaxKind.ModuleBlock || container.kind === SyntaxKind.SourceFile)) { - return undefined; - } - } - else if (modifier === SyntaxKind.AbstractKeyword) { - if (!(container.kind === SyntaxKind.ClassDeclaration || declaration.kind === SyntaxKind.ClassDeclaration)) { - return undefined; - } - } - else { - // unsupported modifier + if (!isLegalModifier(modifier, declaration)) { return undefined; } - const keywords: Node[] = []; - const modifierFlag: ModifierFlags = getFlagFromModifier(modifier); + const modifierFlag = modifierToFlag(modifier); + return mapDefined(getNodesToSearchForModifier(declaration, modifierFlag), node => { + if (getModifierFlags(node) & modifierFlag) { + const mod = find(node.modifiers, m => m.kind === modifier); + Debug.assert(!!mod); + return mod; + } + }); + } - let nodes: ReadonlyArray; + function getNodesToSearchForModifier(declaration: Node, modifierFlag: ModifierFlags): ReadonlyArray { + const container = declaration.parent; switch (container.kind) { case SyntaxKind.ModuleBlock: case SyntaxKind.SourceFile: + case SyntaxKind.Block: + case SyntaxKind.CaseClause: + case SyntaxKind.DefaultClause: // Container is either a class declaration or the declaration is a classDeclaration if (modifierFlag & ModifierFlags.Abstract) { - nodes = [...(declaration).members, declaration]; + return [...(declaration).members, declaration]; } else { - nodes = (container).statements; + return (container).statements; } - break; case SyntaxKind.Constructor: - nodes = [...(container).parameters, ...(container.parent).members]; - break; + return [...(container).parameters, ...(container.parent).members]; case SyntaxKind.ClassDeclaration: case SyntaxKind.ClassExpression: - nodes = (container).members; + const nodes = (container).members; // If we're an accessibility modifier, we're in an instance member and should search // the constructor's parameter list for instance members as well. if (modifierFlag & ModifierFlags.AccessibilityModifier) { - const constructor = forEach((container).members, member => { - return member.kind === SyntaxKind.Constructor && member; - }); - + const constructor = find((container).members, isConstructorDeclaration); if (constructor) { - nodes = [...nodes, ...constructor.parameters]; + return [...nodes, ...constructor.parameters]; } } else if (modifierFlag & ModifierFlags.Abstract) { - nodes = [...nodes, container]; + return [...nodes, container]; } - break; + return nodes; default: Debug.fail("Invalid container kind."); } + } - forEach(nodes, node => { - if (getModifierFlags(node) & modifierFlag) { - forEach(node.modifiers, child => pushKeywordIf(keywords, child, modifier)); - } - }); - - return keywords; - - function getFlagFromModifier(modifier: SyntaxKind) { - switch (modifier) { - case SyntaxKind.PublicKeyword: - return ModifierFlags.Public; - case SyntaxKind.PrivateKeyword: - return ModifierFlags.Private; - case SyntaxKind.ProtectedKeyword: - return ModifierFlags.Protected; - case SyntaxKind.StaticKeyword: - return ModifierFlags.Static; - case SyntaxKind.ExportKeyword: - return ModifierFlags.Export; - case SyntaxKind.DeclareKeyword: - return ModifierFlags.Ambient; - case SyntaxKind.AbstractKeyword: - return ModifierFlags.Abstract; - default: - Debug.fail(); - } + function isLegalModifier(modifier: SyntaxKind, declaration: Node): boolean { + const container = declaration.parent; + switch (modifier) { + case SyntaxKind.PrivateKeyword: + case SyntaxKind.ProtectedKeyword: + case SyntaxKind.PublicKeyword: + switch (container.kind) { + case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: + return true; + case SyntaxKind.Constructor: + return declaration.kind === SyntaxKind.Parameter; + default: + return false; + } + case SyntaxKind.StaticKeyword: + return container.kind === SyntaxKind.ClassDeclaration || container.kind === SyntaxKind.ClassExpression; + case SyntaxKind.ExportKeyword: + case SyntaxKind.DeclareKeyword: + return container.kind === SyntaxKind.ModuleBlock || container.kind === SyntaxKind.SourceFile; + case SyntaxKind.AbstractKeyword: + return container.kind === SyntaxKind.ClassDeclaration || declaration.kind === SyntaxKind.ClassDeclaration; + default: + return false; } } diff --git a/src/services/outliningElementsCollector.ts b/src/services/outliningElementsCollector.ts index 03ae0529ca9..bd294209088 100644 --- a/src/services/outliningElementsCollector.ts +++ b/src/services/outliningElementsCollector.ts @@ -1,7 +1,7 @@ /* @internal */ namespace ts.OutliningElementsCollector { const collapseText = "..."; - const maxDepth = 20; + const maxDepth = 40; const defaultLabel = "#region"; const regionMatch = new RegExp("^\\s*//\\s*#(end)?region(?:\\s+(.*))?$"); diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts index 00cb09412bd..c16a290a30f 100644 --- a/src/services/refactors/extractSymbol.ts +++ b/src/services/refactors/extractSymbol.ts @@ -5,7 +5,7 @@ namespace ts.refactor.extractSymbol { const extractSymbol: Refactor = { name: "Extract Symbol", - description: Diagnostics.Extract_symbol.message, + description: getLocaleSpecificMessage(Diagnostics.Extract_symbol), getAvailableActions, getEditsForAction, }; @@ -43,7 +43,7 @@ namespace ts.refactor.extractSymbol { // Don't issue refactorings with duplicated names. // Scopes come back in "innermost first" order, so extractions will // preferentially go into nearer scopes - const description = formatStringFromArgs(Diagnostics.Extract_to_0_in_1.message, [functionExtraction.description, functionExtraction.scopeDescription]); + const description = functionExtraction.description; if (!usedFunctionNames.has(description)) { usedFunctionNames.set(description, true); functionActions.push({ @@ -58,7 +58,7 @@ namespace ts.refactor.extractSymbol { // Don't issue refactorings with duplicated names. // Scopes come back in "innermost first" order, so extractions will // preferentially go into nearer scopes - const description = formatStringFromArgs(Diagnostics.Extract_to_0_in_1.message, [constantExtraction.description, constantExtraction.scopeDescription]); + const description = constantExtraction.description; if (!usedConstantNames.has(description)) { usedConstantNames.set(description, true); constantActions.push({ @@ -78,7 +78,7 @@ namespace ts.refactor.extractSymbol { if (functionActions.length) { infos.push({ name: extractSymbol.name, - description: Diagnostics.Extract_function.message, + description: getLocaleSpecificMessage(Diagnostics.Extract_function), actions: functionActions }); } @@ -86,7 +86,7 @@ namespace ts.refactor.extractSymbol { if (constantActions.length) { infos.push({ name: extractSymbol.name, - description: Diagnostics.Extract_constant.message, + description: getLocaleSpecificMessage(Diagnostics.Extract_constant), actions: constantActions }); } @@ -127,6 +127,7 @@ namespace ts.refactor.extractSymbol { export const CannotExtractSuper: DiagnosticMessage = createMessage("Cannot extract super call."); export const CannotExtractEmpty: DiagnosticMessage = createMessage("Cannot extract empty range."); export const ExpressionExpected: DiagnosticMessage = createMessage("expression expected."); + export const UselessConstantType: DiagnosticMessage = createMessage("No reason to extract constant of type."); export const StatementOrExpressionExpected: DiagnosticMessage = createMessage("Statement or expression expected."); export const CannotExtractRangeContainingConditionalBreakOrContinueStatements: DiagnosticMessage = createMessage("Cannot extract range containing conditional break or continue statements."); export const CannotExtractRangeContainingConditionalReturnStatement: DiagnosticMessage = createMessage("Cannot extract range containing conditional return statement."); @@ -142,6 +143,7 @@ namespace ts.refactor.extractSymbol { export const CannotAccessVariablesFromNestedScopes = createMessage("Cannot access variables from nested scopes"); export const CannotExtractToOtherFunctionLike = createMessage("Cannot extract method to a function-like scope that is not a function"); export const CannotExtractToJSClass = createMessage("Cannot extract constant to a class scope in JS"); + export const CannotExtractToExpressionArrowFunction = createMessage("Cannot extract constant to an arrow function without a block"); } enum RangeFacts { @@ -523,7 +525,6 @@ namespace ts.refactor.extractSymbol { interface Extraction { readonly description: string; - readonly scopeDescription: string; readonly errors: ReadonlyArray; } @@ -541,23 +542,43 @@ namespace ts.refactor.extractSymbol { const { scopes, readsAndWrites: { functionErrorsPerScope, constantErrorsPerScope } } = getPossibleExtractionsWorker(targetRange, context); // Need the inner type annotation to avoid https://github.com/Microsoft/TypeScript/issues/7547 const extractions = scopes.map((scope, i): ScopeExtractions => { + const functionDescriptionPart = getDescriptionForFunctionInScope(scope); + const constantDescriptionPart = getDescriptionForConstantInScope(scope); + const scopeDescription = isFunctionLikeDeclaration(scope) ? getDescriptionForFunctionLikeDeclaration(scope) : isClassLike(scope) ? getDescriptionForClassLikeDeclaration(scope) : getDescriptionForModuleLikeDeclaration(scope); + + let functionDescription: string; + let constantDescription: string; + if (scopeDescription === SpecialScope.Global) { + functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "global"]); + constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "global"]); + } + else if (scopeDescription === SpecialScope.Module) { + functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "module"]); + constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "module"]); + } + else { + functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1), [functionDescriptionPart, scopeDescription]); + constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1), [constantDescriptionPart, scopeDescription]); + } + + // Customize the phrasing for the innermost scope to increase clarity. + if (i === 0 && !isClassLike(scope)) { + constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_enclosing_scope), [constantDescriptionPart]); + } + return { functionExtraction: { - description: getDescriptionForFunctionInScope(scope), + description: functionDescription, errors: functionErrorsPerScope[i], - scopeDescription, }, constantExtraction: { - description: getDescriptionForConstantInScope(scope), + description: constantDescription, errors: constantErrorsPerScope[i], - scopeDescription: (i === 0 && !isClassLike(scope)) - ? "enclosing scope" // Like "global scope" and "module scope", this is not localized. - : scopeDescription, }, }; }); @@ -626,10 +647,15 @@ namespace ts.refactor.extractSymbol { ? `class '${scope.name.text}'` : scope.name ? `class expression '${scope.name.text}'` : "anonymous class expression"; } - function getDescriptionForModuleLikeDeclaration(scope: SourceFile | ModuleBlock): string { + function getDescriptionForModuleLikeDeclaration(scope: SourceFile | ModuleBlock): string | SpecialScope { return scope.kind === SyntaxKind.ModuleBlock ? `namespace '${scope.parent.name.getText()}'` - : scope.externalModuleIndicator ? "module scope" : "global scope"; + : scope.externalModuleIndicator ? SpecialScope.Module : SpecialScope.Global; + } + + const enum SpecialScope { + Module, + Global, } function getUniqueName(baseName: string, fileText: string): string { @@ -911,12 +937,13 @@ namespace ts.refactor.extractSymbol { const localReference = createIdentifier(localNameText); changeTracker.replaceRange(context.file, { pos: node.getStart(), end: node.end }, localReference); } - else if (node.parent.kind === SyntaxKind.ExpressionStatement) { - // If the parent is an expression statement, replace the statement with the declaration. + else if (node.parent.kind === SyntaxKind.ExpressionStatement && scope === findAncestor(node, isScope)) { + // If the parent is an expression statement and the target scope is the immediately enclosing one, + // replace the statement with the declaration. const newVariableStatement = createVariableStatement( /*modifiers*/ undefined, createVariableDeclarationList([newVariableDeclaration], NodeFlags.Const)); - changeTracker.replaceNodeWithNodes(context.file, node.parent, [newVariableStatement], { nodeSeparator: context.newLineCharacter }); + changeTracker.replaceRange(context.file, { pos: node.parent.getStart(), end: node.parent.end }, newVariableStatement); } else { const newVariableStatement = createVariableStatement( @@ -940,8 +967,14 @@ namespace ts.refactor.extractSymbol { } // Consume - const localReference = createIdentifier(localNameText); - changeTracker.replaceRange(context.file, { pos: node.getStart(), end: node.end }, localReference); + if (node.parent.kind === SyntaxKind.ExpressionStatement) { + // If the parent is an expression statement, delete it. + changeTracker.deleteRange(context.file, { pos: node.parent.getStart(), end: node.parent.end }); + } + else { + const localReference = createIdentifier(localNameText); + changeTracker.replaceRange(context.file, { pos: node.getStart(), end: node.end }, localReference); + } } } @@ -1270,11 +1303,23 @@ namespace ts.refactor.extractSymbol { const constantErrorsPerScope: Diagnostic[][] = []; const visibleDeclarationsInExtractedRange: Symbol[] = []; - const expressionDiagnostic = - isReadonlyArray(targetRange.range) && !(targetRange.range.length === 1 && isExpressionStatement(targetRange.range[0])) - ? ((start, end) => createFileDiagnostic(sourceFile, start, end - start, Messages.ExpressionExpected))(first(targetRange.range).getStart(), last(targetRange.range).end) + const expression = !isReadonlyArray(targetRange.range) + ? targetRange.range + : targetRange.range.length === 1 && isExpressionStatement(targetRange.range[0]) + ? (targetRange.range[0] as ExpressionStatement).expression : undefined; + let expressionDiagnostic: Diagnostic | undefined = undefined; + if (expression === undefined) { + const statements = targetRange.range as ReadonlyArray; + const start = first(statements).getStart(); + const end = last(statements).end; + expressionDiagnostic = createFileDiagnostic(sourceFile, start, end - start, Messages.ExpressionExpected); + } + else if (checker.getTypeAtLocation(expression).flags & (TypeFlags.Void | TypeFlags.Never)) { + expressionDiagnostic = createDiagnosticForNode(expression, Messages.UselessConstantType); + } + // initialize results for (const scope of scopes) { usagesPerScope.push({ usages: createMap(), typeParameterUsages: createMap(), substitutions: createMap<() => Expression>() }); @@ -1292,6 +1337,10 @@ namespace ts.refactor.extractSymbol { if (isClassLike(scope) && isInJavaScriptFile(scope)) { constantErrors.push(createDiagnosticForNode(scope, Messages.CannotExtractToJSClass)); } + if (isArrowFunction(scope) && !isBlock(scope.body)) { + // TODO (https://github.com/Microsoft/TypeScript/issues/18924): allow this + constantErrors.push(createDiagnosticForNode(scope, Messages.CannotExtractToExpressionArrowFunction)); + } constantErrorsPerScope.push(constantErrors); } @@ -1344,14 +1393,13 @@ namespace ts.refactor.extractSymbol { } for (let i = 0; i < scopes.length; i++) { - if (!isReadonlyArray(targetRange.range)) { - const scopeUsages = usagesPerScope[i]; - // Special case: in the innermost scope, all usages are available. - // (The computed value reflects the value at the top-level of the scope, but the - // local will actually be declared at the same level as the extracted expression). - if (i > 0 && (scopeUsages.usages.size > 0 || scopeUsages.typeParameterUsages.size > 0)) { - constantErrorsPerScope[i].push(createDiagnosticForNode(targetRange.range, Messages.CannotAccessVariablesFromNestedScopes)); - } + const scopeUsages = usagesPerScope[i]; + // Special case: in the innermost scope, all usages are available. + // (The computed value reflects the value at the top-level of the scope, but the + // local will actually be declared at the same level as the extracted expression). + if (i > 0 && (scopeUsages.usages.size > 0 || scopeUsages.typeParameterUsages.size > 0)) { + const errorNode = isReadonlyArray(targetRange.range) ? targetRange.range[0] : targetRange.range; + constantErrorsPerScope[i].push(createDiagnosticForNode(errorNode, Messages.CannotAccessVariablesFromNestedScopes)); } let hasWrite = false; diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index de9ff05f9c1..78c06778739 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -7103,6 +7103,7 @@ declare namespace ts.server { */ private projectStateVersion; private typingFiles; + private readonly cancellationToken; isNonTsProject(): boolean; isJsOnlyProject(): boolean; getCachedUnresolvedImportsPerFile_TestOnly(): UnresolvedImportsMap; @@ -7115,7 +7116,7 @@ declare namespace ts.server { getScriptKind(fileName: string): ScriptKind; getScriptVersion(filename: string): string; getScriptSnapshot(filename: string): IScriptSnapshot; - getCancellationToken(): HostCancellationToken; + getCancellationToken(): ThrottledCancellationToken; getCurrentDirectory(): string; getDefaultLibFileName(): string; useCaseSensitiveFileNames(): boolean; 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/baselines/reference/extractConstant/extractConstant_ArrowFunction_Block.js b/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Block.js new file mode 100644 index 00000000000..5e994ae5050 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Block.js @@ -0,0 +1,18 @@ +// ==ORIGINAL== + +const f = () => { + return /*[#|*/2 + 1/*|]*/; +}; +// ==SCOPE::Extract to constant in enclosing scope== + +const f = () => { + const newLocal = 2 + 1; + + return /*RENAME*/newLocal; +}; +// ==SCOPE::Extract to constant in global scope== +const newLocal = 2 + 1; + +const f = () => { + return /*RENAME*/newLocal; +}; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Block.ts b/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Block.ts new file mode 100644 index 00000000000..5e994ae5050 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Block.ts @@ -0,0 +1,18 @@ +// ==ORIGINAL== + +const f = () => { + return /*[#|*/2 + 1/*|]*/; +}; +// ==SCOPE::Extract to constant in enclosing scope== + +const f = () => { + const newLocal = 2 + 1; + + return /*RENAME*/newLocal; +}; +// ==SCOPE::Extract to constant in global scope== +const newLocal = 2 + 1; + +const f = () => { + return /*RENAME*/newLocal; +}; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Expression.js b/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Expression.js new file mode 100644 index 00000000000..76902f4db93 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Expression.js @@ -0,0 +1,6 @@ +// ==ORIGINAL== +const f = () => /*[#|*/2 + 1/*|]*/; +// ==SCOPE::Extract to constant in global scope== +const newLocal = 2 + 1; + +const f = () => /*RENAME*/newLocal; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Expression.ts b/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Expression.ts new file mode 100644 index 00000000000..76902f4db93 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_ArrowFunction_Expression.ts @@ -0,0 +1,6 @@ +// ==ORIGINAL== +const f = () => /*[#|*/2 + 1/*|]*/; +// ==SCOPE::Extract to constant in global scope== +const newLocal = 2 + 1; + +const f = () => /*RENAME*/newLocal; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_BlockScopeMismatch.js b/tests/baselines/reference/extractConstant/extractConstant_BlockScopeMismatch.js index 65871513e18..8231aa543c4 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_BlockScopeMismatch.js +++ b/tests/baselines/reference/extractConstant/extractConstant_BlockScopeMismatch.js @@ -2,7 +2,7 @@ for (let i = 0; i < 10; i++) { for (let j = 0; j < 10; j++) { - const x = i + 1; + const x = /*[#|*/i + 1/*|]*/; } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_BlockScopeMismatch.ts b/tests/baselines/reference/extractConstant/extractConstant_BlockScopeMismatch.ts index 65871513e18..8231aa543c4 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_BlockScopeMismatch.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_BlockScopeMismatch.ts @@ -2,7 +2,7 @@ for (let i = 0; i < 10; i++) { for (let j = 0; j < 10; j++) { - const x = i + 1; + const x = /*[#|*/i + 1/*|]*/; } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_BlockScopes_NoDependencies.js b/tests/baselines/reference/extractConstant/extractConstant_BlockScopes_NoDependencies.js index 4446502920a..4880ee263c5 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_BlockScopes_NoDependencies.js +++ b/tests/baselines/reference/extractConstant/extractConstant_BlockScopes_NoDependencies.js @@ -1,7 +1,7 @@ // ==ORIGINAL== for (let i = 0; i < 10; i++) { for (let j = 0; j < 10; j++) { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_BlockScopes_NoDependencies.ts b/tests/baselines/reference/extractConstant/extractConstant_BlockScopes_NoDependencies.ts index 4446502920a..4880ee263c5 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_BlockScopes_NoDependencies.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_BlockScopes_NoDependencies.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== for (let i = 0; i < 10; i++) { for (let j = 0; j < 10; j++) { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_Class.js b/tests/baselines/reference/extractConstant/extractConstant_Class.js index 6b581141cd6..1e98f8c54d0 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Class.js +++ b/tests/baselines/reference/extractConstant/extractConstant_Class.js @@ -1,6 +1,6 @@ // ==ORIGINAL== class C { - x = 1; + x = /*[#|*/1/*|]*/; } // ==SCOPE::Extract to constant in global scope== const newLocal = 1; diff --git a/tests/baselines/reference/extractConstant/extractConstant_Class.ts b/tests/baselines/reference/extractConstant/extractConstant_Class.ts index eb06cf6c0cf..2c307fc64af 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Class.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_Class.ts @@ -1,6 +1,6 @@ // ==ORIGINAL== class C { - x = 1; + x = /*[#|*/1/*|]*/; } // ==SCOPE::Extract to readonly field in class 'C'== class C { diff --git a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition1.js b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition1.js index 6fa63a655f5..fa2611caaf7 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition1.js +++ b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition1.js @@ -5,7 +5,7 @@ class C { M1() { } M2() { } M3() { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition1.ts b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition1.ts index 15c5d22a34b..dc703945af7 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition1.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition1.ts @@ -5,7 +5,7 @@ class C { M1() { } M2() { } M3() { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition2.js b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition2.js index 3273cfbeaa0..1bd3e03377c 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition2.js +++ b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition2.js @@ -5,7 +5,7 @@ class C { b = 2; M2() { } M3() { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition2.ts b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition2.ts index 777173b0dcd..f95efd91286 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition2.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition2.ts @@ -5,7 +5,7 @@ class C { b = 2; M2() { } M3() { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition3.js b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition3.js index b990075166e..aaa948b77f5 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition3.js +++ b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition3.js @@ -5,7 +5,7 @@ class C { b = 2; M2() { } M3() { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition3.ts b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition3.ts index 516a24b8b20..10454eab67f 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition3.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_ClassInsertionPosition3.ts @@ -5,7 +5,7 @@ class C { b = 2; M2() { } M3() { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_Directive.js b/tests/baselines/reference/extractConstant/extractConstant_Directive.js index 85b9ff76200..b15099c7dd3 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Directive.js +++ b/tests/baselines/reference/extractConstant/extractConstant_Directive.js @@ -2,7 +2,7 @@ "strict"; -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_Directive.ts b/tests/baselines/reference/extractConstant/extractConstant_Directive.ts index 85b9ff76200..b15099c7dd3 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Directive.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_Directive.ts @@ -2,7 +2,7 @@ "strict"; -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatement.js b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatement.js index c3ccdde3b4f..f15e53a0ac5 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatement.js +++ b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatement.js @@ -1,4 +1,4 @@ // ==ORIGINAL== -"hello"; +/*[#|*/"hello";/*|]*/ // ==SCOPE::Extract to constant in enclosing scope== const /*RENAME*/newLocal = "hello"; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatement.ts b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatement.ts index c3ccdde3b4f..f15e53a0ac5 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatement.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatement.ts @@ -1,4 +1,4 @@ // ==ORIGINAL== -"hello"; +/*[#|*/"hello";/*|]*/ // ==SCOPE::Extract to constant in enclosing scope== const /*RENAME*/newLocal = "hello"; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementConsumesLocal.js b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementConsumesLocal.js new file mode 100644 index 00000000000..b7993911d03 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementConsumesLocal.js @@ -0,0 +1,14 @@ +// ==ORIGINAL== + +function F() { + let i = 0; + /*[#|*/i++/*|]*/; +} + +// ==SCOPE::Extract to constant in enclosing scope== + +function F() { + let i = 0; + const /*RENAME*/newLocal = i++; +} + \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementConsumesLocal.ts b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementConsumesLocal.ts new file mode 100644 index 00000000000..b7993911d03 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementConsumesLocal.ts @@ -0,0 +1,14 @@ +// ==ORIGINAL== + +function F() { + let i = 0; + /*[#|*/i++/*|]*/; +} + +// ==SCOPE::Extract to constant in enclosing scope== + +function F() { + let i = 0; + const /*RENAME*/newLocal = i++; +} + \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementExpression.js b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementExpression.js index c3ccdde3b4f..447e1a308b7 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementExpression.js +++ b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementExpression.js @@ -1,4 +1,4 @@ // ==ORIGINAL== -"hello"; +/*[#|*/"hello"/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== const /*RENAME*/newLocal = "hello"; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementExpression.ts b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementExpression.ts index c3ccdde3b4f..447e1a308b7 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementExpression.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementExpression.ts @@ -1,4 +1,4 @@ // ==ORIGINAL== -"hello"; +/*[#|*/"hello"/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== const /*RENAME*/newLocal = "hello"; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementInNestedScope.js b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementInNestedScope.js new file mode 100644 index 00000000000..51c2c07eed8 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementInNestedScope.js @@ -0,0 +1,23 @@ +// ==ORIGINAL== + +let i = 0; +function F() { + /*[#|*/i++/*|]*/; +} + +// ==SCOPE::Extract to constant in enclosing scope== + +let i = 0; +function F() { + const /*RENAME*/newLocal = i++; +} + +// ==SCOPE::Extract to constant in global scope== + +let i = 0; +const /*RENAME*/newLocal = i++; + +function F() { + +} + \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementInNestedScope.ts b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementInNestedScope.ts new file mode 100644 index 00000000000..51c2c07eed8 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_ExpressionStatementInNestedScope.ts @@ -0,0 +1,23 @@ +// ==ORIGINAL== + +let i = 0; +function F() { + /*[#|*/i++/*|]*/; +} + +// ==SCOPE::Extract to constant in enclosing scope== + +let i = 0; +function F() { + const /*RENAME*/newLocal = i++; +} + +// ==SCOPE::Extract to constant in global scope== + +let i = 0; +const /*RENAME*/newLocal = i++; + +function F() { + +} + \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_Function.js b/tests/baselines/reference/extractConstant/extractConstant_Function.js index cff41806566..68b4f83221f 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Function.js +++ b/tests/baselines/reference/extractConstant/extractConstant_Function.js @@ -1,6 +1,6 @@ // ==ORIGINAL== function F() { - let x = 1; + let x = /*[#|*/1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== function F() { diff --git a/tests/baselines/reference/extractConstant/extractConstant_Function.ts b/tests/baselines/reference/extractConstant/extractConstant_Function.ts index cff41806566..68b4f83221f 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Function.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_Function.ts @@ -1,6 +1,6 @@ // ==ORIGINAL== function F() { - let x = 1; + let x = /*[#|*/1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== function F() { diff --git a/tests/baselines/reference/extractConstant/extractConstant_Method.js b/tests/baselines/reference/extractConstant/extractConstant_Method.js index 32b74d00576..95b719ade0d 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Method.js +++ b/tests/baselines/reference/extractConstant/extractConstant_Method.js @@ -1,7 +1,7 @@ // ==ORIGINAL== class C { M() { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_Method.ts b/tests/baselines/reference/extractConstant/extractConstant_Method.ts index 5514b702597..43779492e70 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Method.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_Method.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== class C { M() { - let x = 1; + let x = /*[#|*/1/*|]*/; } } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_MultipleHeaders.js b/tests/baselines/reference/extractConstant/extractConstant_MultipleHeaders.js index 2ccf5932d38..52ea400a0f6 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_MultipleHeaders.js +++ b/tests/baselines/reference/extractConstant/extractConstant_MultipleHeaders.js @@ -6,7 +6,7 @@ "strict"; -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_MultipleHeaders.ts b/tests/baselines/reference/extractConstant/extractConstant_MultipleHeaders.ts index 2ccf5932d38..52ea400a0f6 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_MultipleHeaders.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_MultipleHeaders.ts @@ -6,7 +6,7 @@ "strict"; -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_Namespace.ts b/tests/baselines/reference/extractConstant/extractConstant_Namespace.ts index 81a543d29c4..c9937eb1869 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Namespace.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_Namespace.ts @@ -1,6 +1,6 @@ // ==ORIGINAL== namespace N { - let x = 1; + let x = /*[#|*/1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== namespace N { diff --git a/tests/baselines/reference/extractConstant/extractConstant_Parameters.js b/tests/baselines/reference/extractConstant/extractConstant_Parameters.js index b90f78d96af..6c657f9d5ed 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Parameters.js +++ b/tests/baselines/reference/extractConstant/extractConstant_Parameters.js @@ -1,7 +1,7 @@ // ==ORIGINAL== function F() { let w = 1; - let x = w + 1; + let x = /*[#|*/w + 1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== function F() { diff --git a/tests/baselines/reference/extractConstant/extractConstant_Parameters.ts b/tests/baselines/reference/extractConstant/extractConstant_Parameters.ts index b90f78d96af..6c657f9d5ed 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_Parameters.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_Parameters.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== function F() { let w = 1; - let x = w + 1; + let x = /*[#|*/w + 1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== function F() { diff --git a/tests/baselines/reference/extractConstant/extractConstant_PinnedComment.js b/tests/baselines/reference/extractConstant/extractConstant_PinnedComment.js index cc897b5c6b9..64620d817c6 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_PinnedComment.js +++ b/tests/baselines/reference/extractConstant/extractConstant_PinnedComment.js @@ -2,7 +2,7 @@ /*! Copyright */ -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_PinnedComment.ts b/tests/baselines/reference/extractConstant/extractConstant_PinnedComment.ts index cc897b5c6b9..64620d817c6 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_PinnedComment.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_PinnedComment.ts @@ -2,7 +2,7 @@ /*! Copyright */ -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_PinnedCommentAndDocComment.js b/tests/baselines/reference/extractConstant/extractConstant_PinnedCommentAndDocComment.js index 9ee07c7cd6a..9a3e7322355 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_PinnedCommentAndDocComment.js +++ b/tests/baselines/reference/extractConstant/extractConstant_PinnedCommentAndDocComment.js @@ -3,7 +3,7 @@ /*! Copyright */ /* About x */ -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_PinnedCommentAndDocComment.ts b/tests/baselines/reference/extractConstant/extractConstant_PinnedCommentAndDocComment.ts index 9ee07c7cd6a..9a3e7322355 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_PinnedCommentAndDocComment.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_PinnedCommentAndDocComment.ts @@ -3,7 +3,7 @@ /*! Copyright */ /* About x */ -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_RepeatedSubstitution.ts b/tests/baselines/reference/extractConstant/extractConstant_RepeatedSubstitution.ts index da92e8be933..165852813f0 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_RepeatedSubstitution.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_RepeatedSubstitution.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== namespace X { export const j = 10; - export const y = j * j; + export const y = /*[#|*/j * j/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== namespace X { diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition1.js b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition1.js index 2197dd13e3a..618407155ee 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition1.js +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition1.js @@ -2,7 +2,7 @@ const i = 0; for (let j = 0; j < 10; j++) { - const x = i + 1; + const x = /*[#|*/i + 1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition1.ts b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition1.ts index 2197dd13e3a..618407155ee 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition1.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition1.ts @@ -2,7 +2,7 @@ const i = 0; for (let j = 0; j < 10; j++) { - const x = i + 1; + const x = /*[#|*/i + 1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition2.js b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition2.js index 900798c19ab..5d279a42aa1 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition2.js +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition2.js @@ -3,7 +3,7 @@ const i = 0; function F() { for (let j = 0; j < 10; j++) { - const x = i + 1; + const x = /*[#|*/i + 1/*|]*/; } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition2.ts b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition2.ts index 900798c19ab..5d279a42aa1 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition2.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition2.ts @@ -3,7 +3,7 @@ const i = 0; function F() { for (let j = 0; j < 10; j++) { - const x = i + 1; + const x = /*[#|*/i + 1/*|]*/; } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition3.js b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition3.js index 3f2f7089ef3..bf970bf4ec7 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition3.js +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition3.js @@ -1,7 +1,7 @@ // ==ORIGINAL== for (let j = 0; j < 10; j++) { - const x = 2 + 1; + const x = /*[#|*/2 + 1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition3.ts b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition3.ts index 3f2f7089ef3..bf970bf4ec7 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition3.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition3.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== for (let j = 0; j < 10; j++) { - const x = 2 + 1; + const x = /*[#|*/2 + 1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition4.js b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition4.js index 4c7c2a50217..b8eeb8cdfa5 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition4.js +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition4.js @@ -2,7 +2,7 @@ function F() { for (let j = 0; j < 10; j++) { - const x = 2 + 1; + const x = /*[#|*/2 + 1/*|]*/; } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition4.ts b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition4.ts index 4c7c2a50217..b8eeb8cdfa5 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition4.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition4.ts @@ -2,7 +2,7 @@ function F() { for (let j = 0; j < 10; j++) { - const x = 2 + 1; + const x = /*[#|*/2 + 1/*|]*/; } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition5.js b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition5.js index 4b9647fa445..9ecdbd05502 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition5.js +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition5.js @@ -2,7 +2,7 @@ function F0() { function F1() { - function F2(x = 2 + 1) { + function F2(x = /*[#|*/2 + 1/*|]*/) { } } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition5.ts b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition5.ts index 4b9647fa445..9ecdbd05502 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition5.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition5.ts @@ -2,7 +2,7 @@ function F0() { function F1() { - function F2(x = 2 + 1) { + function F2(x = /*[#|*/2 + 1/*|]*/) { } } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition6.js b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition6.js index 0c81cb756a1..b39af4525a1 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition6.js +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition6.js @@ -1,7 +1,7 @@ // ==ORIGINAL== class C { - x = 2 + 1; + x = /*[#|*/2 + 1/*|]*/; } // ==SCOPE::Extract to constant in global scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition6.ts b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition6.ts index 44a3456fc23..82d48157720 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition6.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition6.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== class C { - x = 2 + 1; + x = /*[#|*/2 + 1/*|]*/; } // ==SCOPE::Extract to readonly field in class 'C'== diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition7.js b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition7.js index f23db0c4aa9..0eb1d12fd48 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition7.js +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition7.js @@ -4,7 +4,7 @@ const i = 0; class C { M() { for (let j = 0; j < 10; j++) { - x = i + 1; + x = /*[#|*/i + 1/*|]*/; } } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition7.ts b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition7.ts index 6867685d6db..42651d6340b 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition7.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_StatementInsertionPosition7.ts @@ -4,7 +4,7 @@ const i = 0; class C { M() { for (let j = 0; j < 10; j++) { - x = i + 1; + x = /*[#|*/i + 1/*|]*/; } } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_TopLevel.js b/tests/baselines/reference/extractConstant/extractConstant_TopLevel.js index fc83d32123e..a6eeb89b7e9 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_TopLevel.js +++ b/tests/baselines/reference/extractConstant/extractConstant_TopLevel.js @@ -1,5 +1,5 @@ // ==ORIGINAL== -let x = 1; +let x = /*[#|*/1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== const newLocal = 1; diff --git a/tests/baselines/reference/extractConstant/extractConstant_TopLevel.ts b/tests/baselines/reference/extractConstant/extractConstant_TopLevel.ts index fc83d32123e..a6eeb89b7e9 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_TopLevel.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_TopLevel.ts @@ -1,5 +1,5 @@ // ==ORIGINAL== -let x = 1; +let x = /*[#|*/1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== const newLocal = 1; diff --git a/tests/baselines/reference/extractConstant/extractConstant_TripleSlash.js b/tests/baselines/reference/extractConstant/extractConstant_TripleSlash.js index e5f87e5d8b8..5479d022a01 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_TripleSlash.js +++ b/tests/baselines/reference/extractConstant/extractConstant_TripleSlash.js @@ -2,7 +2,7 @@ /// -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_TripleSlash.ts b/tests/baselines/reference/extractConstant/extractConstant_TripleSlash.ts index e5f87e5d8b8..5479d022a01 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_TripleSlash.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_TripleSlash.ts @@ -2,7 +2,7 @@ /// -const x = 2 + 1; +const x = /*[#|*/2 + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== diff --git a/tests/baselines/reference/extractConstant/extractConstant_TypeParameters.ts b/tests/baselines/reference/extractConstant/extractConstant_TypeParameters.ts index f9367ab787c..8e6ff785278 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_TypeParameters.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_TypeParameters.ts @@ -1,6 +1,6 @@ // ==ORIGINAL== function F(t: T) { - let x = t + 1; + let x = /*[#|*/t + 1/*|]*/; } // ==SCOPE::Extract to constant in enclosing scope== function F(t: T) { diff --git a/tests/baselines/reference/extractConstant/extractConstant_VariableList_MultipleLines.js b/tests/baselines/reference/extractConstant/extractConstant_VariableList_MultipleLines.js index 18bb4afc28f..7112dc6313d 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_VariableList_MultipleLines.js +++ b/tests/baselines/reference/extractConstant/extractConstant_VariableList_MultipleLines.js @@ -1,6 +1,6 @@ // ==ORIGINAL== const /*About A*/a = 1, - /*About B*/b = a + 1; + /*About B*/b = /*[#|*/a + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== const /*About A*/a = 1, /*About B*/newLocal = a + 1, b = /*RENAME*/newLocal; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_VariableList_MultipleLines.ts b/tests/baselines/reference/extractConstant/extractConstant_VariableList_MultipleLines.ts index 18bb4afc28f..7112dc6313d 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_VariableList_MultipleLines.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_VariableList_MultipleLines.ts @@ -1,6 +1,6 @@ // ==ORIGINAL== const /*About A*/a = 1, - /*About B*/b = a + 1; + /*About B*/b = /*[#|*/a + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== const /*About A*/a = 1, /*About B*/newLocal = a + 1, b = /*RENAME*/newLocal; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_VariableList_const.js b/tests/baselines/reference/extractConstant/extractConstant_VariableList_const.js index 161e5a6a02f..5dd37a7213f 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_VariableList_const.js +++ b/tests/baselines/reference/extractConstant/extractConstant_VariableList_const.js @@ -1,4 +1,4 @@ // ==ORIGINAL== -const a = 1, b = a + 1; +const a = 1, b = /*[#|*/a + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== const a = 1, newLocal = a + 1, b = /*RENAME*/newLocal; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_VariableList_const.ts b/tests/baselines/reference/extractConstant/extractConstant_VariableList_const.ts index 161e5a6a02f..5dd37a7213f 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_VariableList_const.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_VariableList_const.ts @@ -1,4 +1,4 @@ // ==ORIGINAL== -const a = 1, b = a + 1; +const a = 1, b = /*[#|*/a + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== const a = 1, newLocal = a + 1, b = /*RENAME*/newLocal; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_VariableList_let.js b/tests/baselines/reference/extractConstant/extractConstant_VariableList_let.js index bc05b13ba7e..9a65c59c78a 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_VariableList_let.js +++ b/tests/baselines/reference/extractConstant/extractConstant_VariableList_let.js @@ -1,4 +1,4 @@ // ==ORIGINAL== -let a = 1, b = a + 1; +let a = 1, b = /*[#|*/a + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== let a = 1, newLocal = a + 1, b = /*RENAME*/newLocal; \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_VariableList_let.ts b/tests/baselines/reference/extractConstant/extractConstant_VariableList_let.ts index bc05b13ba7e..9a65c59c78a 100644 --- a/tests/baselines/reference/extractConstant/extractConstant_VariableList_let.ts +++ b/tests/baselines/reference/extractConstant/extractConstant_VariableList_let.ts @@ -1,4 +1,4 @@ // ==ORIGINAL== -let a = 1, b = a + 1; +let a = 1, b = /*[#|*/a + 1/*|]*/; // ==SCOPE::Extract to constant in enclosing scope== let a = 1, newLocal = a + 1, b = /*RENAME*/newLocal; \ No newline at end of file diff --git a/tests/baselines/reference/extractFunction/extractFunction1.ts b/tests/baselines/reference/extractFunction/extractFunction1.ts index 74303bbf3e1..8243644e1ef 100644 --- a/tests/baselines/reference/extractFunction/extractFunction1.ts +++ b/tests/baselines/reference/extractFunction/extractFunction1.ts @@ -6,11 +6,11 @@ namespace A { namespace B { function a() { let a = 1; - + /*[#|*/ let y = 5; let z = x; a = y; - foo(); + foo();/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction10.ts b/tests/baselines/reference/extractFunction/extractFunction10.ts index 65fbc9fb4c9..a15381c1a18 100644 --- a/tests/baselines/reference/extractFunction/extractFunction10.ts +++ b/tests/baselines/reference/extractFunction/extractFunction10.ts @@ -4,8 +4,8 @@ namespace A { class C { a() { let z = 1; - let a1: I = { x: 1 }; - return a1.x + 10; + /*[#|*/let a1: I = { x: 1 }; + return a1.x + 10;/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction11.ts b/tests/baselines/reference/extractFunction/extractFunction11.ts index 55472063055..d07a1826439 100644 --- a/tests/baselines/reference/extractFunction/extractFunction11.ts +++ b/tests/baselines/reference/extractFunction/extractFunction11.ts @@ -4,10 +4,10 @@ namespace A { class C { a() { let z = 1; - let a1 = { x: 1 }; + /*[#|*/let a1 = { x: 1 }; y = 10; z = 42; - return a1.x + 10; + return a1.x + 10;/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction12.ts b/tests/baselines/reference/extractFunction/extractFunction12.ts index c8f066657a2..37274bdcc87 100644 --- a/tests/baselines/reference/extractFunction/extractFunction12.ts +++ b/tests/baselines/reference/extractFunction/extractFunction12.ts @@ -5,11 +5,11 @@ namespace A { b() {} a() { let z = 1; - let a1 = { x: 1 }; + /*[#|*/let a1 = { x: 1 }; y = 10; z = 42; this.b(); - return a1.x + 10; + return a1.x + 10;/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction13.ts b/tests/baselines/reference/extractFunction/extractFunction13.ts index c40f29711f4..4987039d5da 100644 --- a/tests/baselines/reference/extractFunction/extractFunction13.ts +++ b/tests/baselines/reference/extractFunction/extractFunction13.ts @@ -4,11 +4,11 @@ (u2a: U2a, u2b: U2b) => { function F2(t2a: T2a, t2b: T2b) { (u3a: U3a, u3b: U3b) => { - t1a.toString(); + /*[#|*/t1a.toString(); t2a.toString(); u1a.toString(); u2a.toString(); - u3a.toString(); + u3a.toString();/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction14.ts b/tests/baselines/reference/extractFunction/extractFunction14.ts index 943c8250edd..53cabbe600f 100644 --- a/tests/baselines/reference/extractFunction/extractFunction14.ts +++ b/tests/baselines/reference/extractFunction/extractFunction14.ts @@ -1,8 +1,8 @@ // ==ORIGINAL== function F(t1: T) { function G(t2: T) { - t1.toString(); - t2.toString(); + /*[#|*/t1.toString(); + t2.toString();/*|]*/ } } // ==SCOPE::Extract to inner function in function 'G'== diff --git a/tests/baselines/reference/extractFunction/extractFunction15.ts b/tests/baselines/reference/extractFunction/extractFunction15.ts index b6e3e0f04b6..a09383282aa 100644 --- a/tests/baselines/reference/extractFunction/extractFunction15.ts +++ b/tests/baselines/reference/extractFunction/extractFunction15.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== function F(t1: T) { function G(t2: U) { - t2.toString(); + /*[#|*/t2.toString();/*|]*/ } } // ==SCOPE::Extract to inner function in function 'G'== diff --git a/tests/baselines/reference/extractFunction/extractFunction16.ts b/tests/baselines/reference/extractFunction/extractFunction16.ts index 223307ff349..79c72f31198 100644 --- a/tests/baselines/reference/extractFunction/extractFunction16.ts +++ b/tests/baselines/reference/extractFunction/extractFunction16.ts @@ -1,6 +1,6 @@ // ==ORIGINAL== function F() { - const array: T[] = []; + const array: T[] = /*[#|*/[]/*|]*/; } // ==SCOPE::Extract to inner function in function 'F'== function F() { diff --git a/tests/baselines/reference/extractFunction/extractFunction17.ts b/tests/baselines/reference/extractFunction/extractFunction17.ts index e1f20af6867..733b1b27623 100644 --- a/tests/baselines/reference/extractFunction/extractFunction17.ts +++ b/tests/baselines/reference/extractFunction/extractFunction17.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== class C { M(t1: T1, t2: T2) { - t1.toString(); + /*[#|*/t1.toString()/*|]*/; } } // ==SCOPE::Extract to method in class 'C'== diff --git a/tests/baselines/reference/extractFunction/extractFunction18.ts b/tests/baselines/reference/extractFunction/extractFunction18.ts index 775a1f3ed15..8c44de12981 100644 --- a/tests/baselines/reference/extractFunction/extractFunction18.ts +++ b/tests/baselines/reference/extractFunction/extractFunction18.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== class C { M(t1: T1, t2: T2) { - t1.toString(); + /*[#|*/t1.toString()/*|]*/; } } // ==SCOPE::Extract to method in class 'C'== diff --git a/tests/baselines/reference/extractFunction/extractFunction19.ts b/tests/baselines/reference/extractFunction/extractFunction19.ts index e9107198b18..3a2723513f4 100644 --- a/tests/baselines/reference/extractFunction/extractFunction19.ts +++ b/tests/baselines/reference/extractFunction/extractFunction19.ts @@ -1,6 +1,6 @@ // ==ORIGINAL== function F(v: V) { - v.toString(); + /*[#|*/v.toString()/*|]*/; } // ==SCOPE::Extract to inner function in function 'F'== function F(v: V) { diff --git a/tests/baselines/reference/extractFunction/extractFunction2.ts b/tests/baselines/reference/extractFunction/extractFunction2.ts index 201dd173adc..3872812b312 100644 --- a/tests/baselines/reference/extractFunction/extractFunction2.ts +++ b/tests/baselines/reference/extractFunction/extractFunction2.ts @@ -5,10 +5,10 @@ namespace A { } namespace B { function a() { - + /*[#|*/ let y = 5; let z = x; - return foo(); + return foo();/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction20.js b/tests/baselines/reference/extractFunction/extractFunction20.js index 455fee113fb..b65d3dae5da 100644 --- a/tests/baselines/reference/extractFunction/extractFunction20.js +++ b/tests/baselines/reference/extractFunction/extractFunction20.js @@ -1,8 +1,8 @@ // ==ORIGINAL== const _ = class { a() { - let a1 = { x: 1 }; - return a1.x + 10; + /*[#|*/let a1 = { x: 1 }; + return a1.x + 10;/*|]*/ } } // ==SCOPE::Extract to method in anonymous class expression== diff --git a/tests/baselines/reference/extractFunction/extractFunction20.ts b/tests/baselines/reference/extractFunction/extractFunction20.ts index 723d8a99ca6..1fe72020ad7 100644 --- a/tests/baselines/reference/extractFunction/extractFunction20.ts +++ b/tests/baselines/reference/extractFunction/extractFunction20.ts @@ -1,8 +1,8 @@ // ==ORIGINAL== const _ = class { a() { - let a1 = { x: 1 }; - return a1.x + 10; + /*[#|*/let a1 = { x: 1 }; + return a1.x + 10;/*|]*/ } } // ==SCOPE::Extract to method in anonymous class expression== diff --git a/tests/baselines/reference/extractFunction/extractFunction21.js b/tests/baselines/reference/extractFunction/extractFunction21.js index af7928a039f..4454f36ac62 100644 --- a/tests/baselines/reference/extractFunction/extractFunction21.js +++ b/tests/baselines/reference/extractFunction/extractFunction21.js @@ -1,8 +1,8 @@ // ==ORIGINAL== function foo() { let x = 10; - x++; - return; + /*[#|*/x++; + return;/*|]*/ } // ==SCOPE::Extract to inner function in function 'foo'== function foo() { diff --git a/tests/baselines/reference/extractFunction/extractFunction21.ts b/tests/baselines/reference/extractFunction/extractFunction21.ts index b0469d81384..530a10bea95 100644 --- a/tests/baselines/reference/extractFunction/extractFunction21.ts +++ b/tests/baselines/reference/extractFunction/extractFunction21.ts @@ -1,8 +1,8 @@ // ==ORIGINAL== function foo() { let x = 10; - x++; - return; + /*[#|*/x++; + return;/*|]*/ } // ==SCOPE::Extract to inner function in function 'foo'== function foo() { diff --git a/tests/baselines/reference/extractFunction/extractFunction22.js b/tests/baselines/reference/extractFunction/extractFunction22.js index 09fbc7a5b82..60891105c6e 100644 --- a/tests/baselines/reference/extractFunction/extractFunction22.js +++ b/tests/baselines/reference/extractFunction/extractFunction22.js @@ -3,7 +3,7 @@ function test() { try { } finally { - return 1; + /*[#|*/return 1;/*|]*/ } } // ==SCOPE::Extract to inner function in function 'test'== diff --git a/tests/baselines/reference/extractFunction/extractFunction22.ts b/tests/baselines/reference/extractFunction/extractFunction22.ts index 09fbc7a5b82..60891105c6e 100644 --- a/tests/baselines/reference/extractFunction/extractFunction22.ts +++ b/tests/baselines/reference/extractFunction/extractFunction22.ts @@ -3,7 +3,7 @@ function test() { try { } finally { - return 1; + /*[#|*/return 1;/*|]*/ } } // ==SCOPE::Extract to inner function in function 'test'== diff --git a/tests/baselines/reference/extractFunction/extractFunction23.ts b/tests/baselines/reference/extractFunction/extractFunction23.ts index 1a0eaf098fd..3092d6490ba 100644 --- a/tests/baselines/reference/extractFunction/extractFunction23.ts +++ b/tests/baselines/reference/extractFunction/extractFunction23.ts @@ -2,7 +2,7 @@ namespace NS { function M1() { } function M2() { - return 1; + /*[#|*/return 1;/*|]*/ } function M3() { } } diff --git a/tests/baselines/reference/extractFunction/extractFunction24.js b/tests/baselines/reference/extractFunction/extractFunction24.js index 7b80180c5d3..dbac567afc6 100644 --- a/tests/baselines/reference/extractFunction/extractFunction24.js +++ b/tests/baselines/reference/extractFunction/extractFunction24.js @@ -2,7 +2,7 @@ function Outer() { function M1() { } function M2() { - return 1; + /*[#|*/return 1;/*|]*/ } function M3() { } } diff --git a/tests/baselines/reference/extractFunction/extractFunction24.ts b/tests/baselines/reference/extractFunction/extractFunction24.ts index 7b80180c5d3..dbac567afc6 100644 --- a/tests/baselines/reference/extractFunction/extractFunction24.ts +++ b/tests/baselines/reference/extractFunction/extractFunction24.ts @@ -2,7 +2,7 @@ function Outer() { function M1() { } function M2() { - return 1; + /*[#|*/return 1;/*|]*/ } function M3() { } } diff --git a/tests/baselines/reference/extractFunction/extractFunction25.js b/tests/baselines/reference/extractFunction/extractFunction25.js index 3233c404307..8afa266246d 100644 --- a/tests/baselines/reference/extractFunction/extractFunction25.js +++ b/tests/baselines/reference/extractFunction/extractFunction25.js @@ -1,7 +1,7 @@ // ==ORIGINAL== function M1() { } function M2() { - return 1; + /*[#|*/return 1;/*|]*/ } function M3() { } // ==SCOPE::Extract to inner function in function 'M2'== diff --git a/tests/baselines/reference/extractFunction/extractFunction25.ts b/tests/baselines/reference/extractFunction/extractFunction25.ts index 3233c404307..8afa266246d 100644 --- a/tests/baselines/reference/extractFunction/extractFunction25.ts +++ b/tests/baselines/reference/extractFunction/extractFunction25.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== function M1() { } function M2() { - return 1; + /*[#|*/return 1;/*|]*/ } function M3() { } // ==SCOPE::Extract to inner function in function 'M2'== diff --git a/tests/baselines/reference/extractFunction/extractFunction26.js b/tests/baselines/reference/extractFunction/extractFunction26.js index ccc4bacb477..c05af641d4b 100644 --- a/tests/baselines/reference/extractFunction/extractFunction26.js +++ b/tests/baselines/reference/extractFunction/extractFunction26.js @@ -2,7 +2,7 @@ class C { M1() { } M2() { - return 1; + /*[#|*/return 1;/*|]*/ } M3() { } } diff --git a/tests/baselines/reference/extractFunction/extractFunction26.ts b/tests/baselines/reference/extractFunction/extractFunction26.ts index 6f4d85c7801..37eba24bfde 100644 --- a/tests/baselines/reference/extractFunction/extractFunction26.ts +++ b/tests/baselines/reference/extractFunction/extractFunction26.ts @@ -2,7 +2,7 @@ class C { M1() { } M2() { - return 1; + /*[#|*/return 1;/*|]*/ } M3() { } } diff --git a/tests/baselines/reference/extractFunction/extractFunction27.js b/tests/baselines/reference/extractFunction/extractFunction27.js index 1f894d17bad..96bca6b24c5 100644 --- a/tests/baselines/reference/extractFunction/extractFunction27.js +++ b/tests/baselines/reference/extractFunction/extractFunction27.js @@ -2,7 +2,7 @@ class C { M1() { } M2() { - return 1; + /*[#|*/return 1;/*|]*/ } constructor() { } M3() { } diff --git a/tests/baselines/reference/extractFunction/extractFunction27.ts b/tests/baselines/reference/extractFunction/extractFunction27.ts index 3426c4ec5c3..335d74e002d 100644 --- a/tests/baselines/reference/extractFunction/extractFunction27.ts +++ b/tests/baselines/reference/extractFunction/extractFunction27.ts @@ -2,7 +2,7 @@ class C { M1() { } M2() { - return 1; + /*[#|*/return 1;/*|]*/ } constructor() { } M3() { } diff --git a/tests/baselines/reference/extractFunction/extractFunction28.js b/tests/baselines/reference/extractFunction/extractFunction28.js index d205edbd4bf..a82b864448d 100644 --- a/tests/baselines/reference/extractFunction/extractFunction28.js +++ b/tests/baselines/reference/extractFunction/extractFunction28.js @@ -2,7 +2,7 @@ class C { M1() { } M2() { - return 1; + /*[#|*/return 1;/*|]*/ } M3() { } constructor() { } diff --git a/tests/baselines/reference/extractFunction/extractFunction28.ts b/tests/baselines/reference/extractFunction/extractFunction28.ts index b6e94cb47c5..bde2661f934 100644 --- a/tests/baselines/reference/extractFunction/extractFunction28.ts +++ b/tests/baselines/reference/extractFunction/extractFunction28.ts @@ -2,7 +2,7 @@ class C { M1() { } M2() { - return 1; + /*[#|*/return 1;/*|]*/ } M3() { } constructor() { } diff --git a/tests/baselines/reference/extractFunction/extractFunction29.ts b/tests/baselines/reference/extractFunction/extractFunction29.ts index 9baea5870f5..492db8e6df9 100644 --- a/tests/baselines/reference/extractFunction/extractFunction29.ts +++ b/tests/baselines/reference/extractFunction/extractFunction29.ts @@ -6,11 +6,11 @@ interface UnaryExpression { } function parseUnaryExpression(operator: string): UnaryExpression { - return { + /*[#|*/return { kind: "Unary", operator, operand: parsePrimaryExpression(), - }; + };/*|]*/ } function parsePrimaryExpression(): any { diff --git a/tests/baselines/reference/extractFunction/extractFunction3.ts b/tests/baselines/reference/extractFunction/extractFunction3.ts index b5ae7592157..9c4c1aaa9d7 100644 --- a/tests/baselines/reference/extractFunction/extractFunction3.ts +++ b/tests/baselines/reference/extractFunction/extractFunction3.ts @@ -4,10 +4,10 @@ namespace A { } namespace B { function* a(z: number) { - + /*[#|*/ let y = 5; yield z; - return foo(); + return foo();/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction30.ts b/tests/baselines/reference/extractFunction/extractFunction30.ts index 35b86b668ff..b57b48c30a9 100644 --- a/tests/baselines/reference/extractFunction/extractFunction30.ts +++ b/tests/baselines/reference/extractFunction/extractFunction30.ts @@ -1,6 +1,6 @@ // ==ORIGINAL== function F() { - let t: T; + /*[#|*/let t: T;/*|]*/ } // ==SCOPE::Extract to inner function in function 'F'== function F() { diff --git a/tests/baselines/reference/extractFunction/extractFunction31.ts b/tests/baselines/reference/extractFunction/extractFunction31.ts index 77120091828..d7252a14011 100644 --- a/tests/baselines/reference/extractFunction/extractFunction31.ts +++ b/tests/baselines/reference/extractFunction/extractFunction31.ts @@ -5,9 +5,9 @@ namespace N { () => { var f: () => number; - f = function (): number { + /*[#|*/f = function (): number { return value; - } + }/*|]*/ } } // ==SCOPE::Extract to function in namespace 'N'== diff --git a/tests/baselines/reference/extractFunction/extractFunction32.ts b/tests/baselines/reference/extractFunction/extractFunction32.ts index 529b81e8f9b..4070763b79f 100644 --- a/tests/baselines/reference/extractFunction/extractFunction32.ts +++ b/tests/baselines/reference/extractFunction/extractFunction32.ts @@ -4,11 +4,11 @@ namespace N { export const value = 1; () => { - var c = class { + /*[#|*/var c = class { M() { return value; } - } + }/*|]*/ } } // ==SCOPE::Extract to function in namespace 'N'== diff --git a/tests/baselines/reference/extractFunction/extractFunction33.js b/tests/baselines/reference/extractFunction/extractFunction33.js index fd716646e66..46c0f176b56 100644 --- a/tests/baselines/reference/extractFunction/extractFunction33.js +++ b/tests/baselines/reference/extractFunction/extractFunction33.js @@ -1,6 +1,6 @@ // ==ORIGINAL== function F() { - function G() { } + /*[#|*/function G() { }/*|]*/ } // ==SCOPE::Extract to inner function in function 'F'== function F() { diff --git a/tests/baselines/reference/extractFunction/extractFunction33.ts b/tests/baselines/reference/extractFunction/extractFunction33.ts index fd716646e66..46c0f176b56 100644 --- a/tests/baselines/reference/extractFunction/extractFunction33.ts +++ b/tests/baselines/reference/extractFunction/extractFunction33.ts @@ -1,6 +1,6 @@ // ==ORIGINAL== function F() { - function G() { } + /*[#|*/function G() { }/*|]*/ } // ==SCOPE::Extract to inner function in function 'F'== function F() { diff --git a/tests/baselines/reference/extractFunction/extractFunction4.ts b/tests/baselines/reference/extractFunction/extractFunction4.ts index 6ef3e843ee1..4108976b6b3 100644 --- a/tests/baselines/reference/extractFunction/extractFunction4.ts +++ b/tests/baselines/reference/extractFunction/extractFunction4.ts @@ -4,12 +4,12 @@ namespace A { } namespace B { async function a(z: number, z1: any) { - + /*[#|*/ let y = 5; if (z) { await z1; } - return foo(); + return foo();/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction5.ts b/tests/baselines/reference/extractFunction/extractFunction5.ts index e2f72721b95..3122ba24553 100644 --- a/tests/baselines/reference/extractFunction/extractFunction5.ts +++ b/tests/baselines/reference/extractFunction/extractFunction5.ts @@ -6,11 +6,11 @@ namespace A { namespace B { function a() { let a = 1; - + /*[#|*/ let y = 5; let z = x; a = y; - foo(); + foo();/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction6.ts b/tests/baselines/reference/extractFunction/extractFunction6.ts index 6b4852dc722..f6c94216b46 100644 --- a/tests/baselines/reference/extractFunction/extractFunction6.ts +++ b/tests/baselines/reference/extractFunction/extractFunction6.ts @@ -6,11 +6,11 @@ namespace A { namespace B { function a() { let a = 1; - + /*[#|*/ let y = 5; let z = x; a = y; - return foo(); + return foo();/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction7.ts b/tests/baselines/reference/extractFunction/extractFunction7.ts index 9712cedda8d..91377868e0f 100644 --- a/tests/baselines/reference/extractFunction/extractFunction7.ts +++ b/tests/baselines/reference/extractFunction/extractFunction7.ts @@ -8,11 +8,11 @@ namespace A { namespace B { function a() { let a = 1; - + /*[#|*/ let y = 5; let z = x; a = y; - return C.foo(); + return C.foo();/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction9.ts b/tests/baselines/reference/extractFunction/extractFunction9.ts index 9c1f81edf45..7db12096cbc 100644 --- a/tests/baselines/reference/extractFunction/extractFunction9.ts +++ b/tests/baselines/reference/extractFunction/extractFunction9.ts @@ -3,8 +3,8 @@ namespace A { export interface I { x: number }; namespace B { function a() { - let a1: I = { x: 1 }; - return a1.x + 10; + /*[#|*/let a1: I = { x: 1 }; + return a1.x + 10;/*|]*/ } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction_RepeatedSubstitution.ts b/tests/baselines/reference/extractFunction/extractFunction_RepeatedSubstitution.ts index 080f694360d..68cc7d2248a 100644 --- a/tests/baselines/reference/extractFunction/extractFunction_RepeatedSubstitution.ts +++ b/tests/baselines/reference/extractFunction/extractFunction_RepeatedSubstitution.ts @@ -1,7 +1,7 @@ // ==ORIGINAL== namespace X { export const j = 10; - export const y = j * j; + export const y = /*[#|*/j * j/*|]*/; } // ==SCOPE::Extract to function in namespace 'X'== namespace X { diff --git a/tests/baselines/reference/jsdocAugments_qualifiedName.symbols b/tests/baselines/reference/jsdocAugments_qualifiedName.symbols new file mode 100644 index 00000000000..3a69c385c0b --- /dev/null +++ b/tests/baselines/reference/jsdocAugments_qualifiedName.symbols @@ -0,0 +1,12 @@ +=== /a.js === +export class A {} +>A : Symbol(A, Decl(a.js, 0, 0)) + +=== /b.js === +import * as a from "./a"; +>a : Symbol(a, Decl(b.js, 0, 6)) + +/** @augments a.A */ +class B {} +>B : Symbol(B, Decl(b.js, 0, 25)) + diff --git a/tests/baselines/reference/jsdocAugments_qualifiedName.types b/tests/baselines/reference/jsdocAugments_qualifiedName.types new file mode 100644 index 00000000000..21928f0b7d0 --- /dev/null +++ b/tests/baselines/reference/jsdocAugments_qualifiedName.types @@ -0,0 +1,12 @@ +=== /a.js === +export class A {} +>A : A + +=== /b.js === +import * as a from "./a"; +>a : typeof a + +/** @augments a.A */ +class B {} +>B : B + diff --git a/tests/cases/compiler/APISample_compile.ts b/tests/cases/compiler/APISample_compile.ts index c49d2a7b122..35fe8192e78 100644 --- a/tests/cases/compiler/APISample_compile.ts +++ b/tests/cases/compiler/APISample_compile.ts @@ -1,4 +1,5 @@ // @module: commonjs +// @skipLibCheck: true // @includebuiltfile: typescript_standalone.d.ts // @noImplicitAny:true // @strictNullChecks:true diff --git a/tests/cases/compiler/APISample_jsdoc.ts b/tests/cases/compiler/APISample_jsdoc.ts index 70b814ffff4..2f4e08931d6 100644 --- a/tests/cases/compiler/APISample_jsdoc.ts +++ b/tests/cases/compiler/APISample_jsdoc.ts @@ -1,4 +1,5 @@ // @module: commonjs +// @skipLibCheck: true // @includebuiltfile: typescript_standalone.d.ts // @strict:true diff --git a/tests/cases/compiler/APISample_linter.ts b/tests/cases/compiler/APISample_linter.ts index dc5e2644b4f..0d8dc0190fe 100644 --- a/tests/cases/compiler/APISample_linter.ts +++ b/tests/cases/compiler/APISample_linter.ts @@ -1,4 +1,5 @@ // @module: commonjs +// @skipLibCheck: true // @includebuiltfile: typescript_standalone.d.ts // @noImplicitAny:true // @strictNullChecks:true diff --git a/tests/cases/compiler/APISample_parseConfig.ts b/tests/cases/compiler/APISample_parseConfig.ts index f59f64dc4ad..c3094a93988 100644 --- a/tests/cases/compiler/APISample_parseConfig.ts +++ b/tests/cases/compiler/APISample_parseConfig.ts @@ -1,4 +1,5 @@ // @module: commonjs +// @skipLibCheck: true // @includebuiltfile: typescript_standalone.d.ts // @noImplicitAny:true // @strictNullChecks:true diff --git a/tests/cases/compiler/APISample_transform.ts b/tests/cases/compiler/APISample_transform.ts index a76d6b15463..c7b0fad8e75 100644 --- a/tests/cases/compiler/APISample_transform.ts +++ b/tests/cases/compiler/APISample_transform.ts @@ -1,4 +1,5 @@ // @module: commonjs +// @skipLibCheck: true // @includebuiltfile: typescript_standalone.d.ts // @noImplicitAny:true // @strictNullChecks:true diff --git a/tests/cases/compiler/APISample_watcher.ts b/tests/cases/compiler/APISample_watcher.ts index 436a1401d57..5be0e9e38ad 100644 --- a/tests/cases/compiler/APISample_watcher.ts +++ b/tests/cases/compiler/APISample_watcher.ts @@ -1,4 +1,5 @@ // @module: commonjs +// @skipLibCheck: true // @includebuiltfile: typescript_standalone.d.ts // @noImplicitAny:true // @strictNullChecks:true 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/compiler/contextuallyTypeArgumentsKeyword.ts b/tests/cases/compiler/contextuallyTypeArgumentsKeyword.ts index 9421e70c4e8..f7d55974bf9 100644 --- a/tests/cases/compiler/contextuallyTypeArgumentsKeyword.ts +++ b/tests/cases/compiler/contextuallyTypeArgumentsKeyword.ts @@ -1,6 +1,7 @@ // @noEmit: true // @allowJs: true // @checkJs: true +// @skipLibCheck: true // @lib: es2017, dom // @Filename: foo.js // Repro for #16585 diff --git a/tests/cases/compiler/correctOrderOfPromiseMethod.ts b/tests/cases/compiler/correctOrderOfPromiseMethod.ts index 069c900a4aa..85f4be9843c 100644 --- a/tests/cases/compiler/correctOrderOfPromiseMethod.ts +++ b/tests/cases/compiler/correctOrderOfPromiseMethod.ts @@ -1,3 +1,4 @@ +// @skipLibCheck: true // @lib: dom, es7 interface A { diff --git a/tests/cases/compiler/jsdocAugments_qualifiedName.ts b/tests/cases/compiler/jsdocAugments_qualifiedName.ts new file mode 100644 index 00000000000..ccd14480936 --- /dev/null +++ b/tests/cases/compiler/jsdocAugments_qualifiedName.ts @@ -0,0 +1,11 @@ +// @allowJs: true +// @checkJs: true +// @noEmit: true + +// @Filename: /a.js +export class A {} + +// @Filename: /b.js +import * as a from "./a"; +/** @augments a.A */ +class B {} diff --git a/tests/cases/compiler/metadataOfEventAlias.ts b/tests/cases/compiler/metadataOfEventAlias.ts index c62e1480c89..a5b8ffea850 100644 --- a/tests/cases/compiler/metadataOfEventAlias.ts +++ b/tests/cases/compiler/metadataOfEventAlias.ts @@ -1,6 +1,7 @@ // @experimentalDecorators: true // @emitDecoratorMetadata: true // @target: es5 +// @skipLibCheck: true // @includeBuiltFile: lib.d.ts // @filename: event.ts diff --git a/tests/cases/compiler/modularizeLibrary_Dom.iterable.ts b/tests/cases/compiler/modularizeLibrary_Dom.iterable.ts index 3488d255eaa..dbbeea15da6 100644 --- a/tests/cases/compiler/modularizeLibrary_Dom.iterable.ts +++ b/tests/cases/compiler/modularizeLibrary_Dom.iterable.ts @@ -1,4 +1,5 @@ -// @lib: es6,dom,dom.iterable +// @skipLibCheck: true +// @lib: es6,dom,dom.iterable // @target: es6 for (const element of document.getElementsByTagName("a")) { diff --git a/tests/cases/compiler/symbolMergeValueAndImportedType.ts b/tests/cases/compiler/symbolMergeValueAndImportedType.ts index 4779ff22e9d..4865700c519 100644 --- a/tests/cases/compiler/symbolMergeValueAndImportedType.ts +++ b/tests/cases/compiler/symbolMergeValueAndImportedType.ts @@ -1,5 +1,6 @@ // @target: es2015 // @module: commonjs +// @skipLibCheck: true // @lib: es2015,dom // @filename: main.ts import { X } from "./other"; 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/checkJsxChildrenProperty12.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty12.tsx index e49b196b8f8..679ec057999 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty12.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty12.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/checkJsxChildrenProperty3.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty3.tsx index c67c6d5440d..c70a2292fa2 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty3.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty3.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/checkJsxChildrenProperty5.tsx b/tests/cases/conformance/jsx/checkJsxChildrenProperty5.tsx index 6143e4b0faf..9b9dfac02b2 100644 --- a/tests/cases/conformance/jsx/checkJsxChildrenProperty5.tsx +++ b/tests/cases/conformance/jsx/checkJsxChildrenProperty5.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/correctlyMarkAliasAsReferences1.tsx b/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences1.tsx index a074b3b8086..a27c3114532 100644 --- a/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences1.tsx +++ b/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences1.tsx @@ -1,6 +1,7 @@ // @target: es2017 // @jsx: react // @moduleResolution: node +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts // @filename: declaration.d.ts diff --git a/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences2.tsx b/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences2.tsx index 9755c624fc5..1fff751b61c 100644 --- a/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences2.tsx +++ b/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences2.tsx @@ -1,6 +1,7 @@ // @target: es2017 // @jsx: react // @moduleResolution: node +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts // @filename: declaration.d.ts diff --git a/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences3.tsx b/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences3.tsx index c3bfb0c8a47..2144478d2d6 100644 --- a/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences3.tsx +++ b/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences3.tsx @@ -2,6 +2,7 @@ // @jsx: react // @moduleResolution: node // @noImplicitAny: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts // @filename: declaration.d.ts diff --git a/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences4.tsx b/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences4.tsx index edb9f75f87b..165c91cc39e 100644 --- a/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences4.tsx +++ b/tests/cases/conformance/jsx/correctlyMarkAliasAsReferences4.tsx @@ -1,6 +1,7 @@ // @target: es2017 // @jsx: react // @moduleResolution: node +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts // @filename: declaration.d.ts 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/tsxGenericAttributesType4.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType4.tsx index b207f2b4398..2c134d4e20e 100644 --- a/tests/cases/conformance/jsx/tsxGenericAttributesType4.tsx +++ b/tests/cases/conformance/jsx/tsxGenericAttributesType4.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/tsxSfcReturnNull.tsx b/tests/cases/conformance/jsx/tsxSfcReturnNull.tsx index 436b361eaf8..167fbd25c66 100644 --- a/tests/cases/conformance/jsx/tsxSfcReturnNull.tsx +++ b/tests/cases/conformance/jsx/tsxSfcReturnNull.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/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/tsxSpreadAttributesResolution3.tsx b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution3.tsx index 8bff2abbd2c..1ddf7bca081 100644 --- a/tests/cases/conformance/jsx/tsxSpreadAttributesResolution3.tsx +++ b/tests/cases/conformance/jsx/tsxSpreadAttributesResolution3.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/tsxStatelessFunctionComponentOverload1.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload1.tsx index 525d035cbfe..b0da4223ce3 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload1.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload1.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/tsxStatelessFunctionComponentOverload2.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload2.tsx index 53f21b8edac..bd86e991a2f 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload2.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload2.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/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/tsxStatelessFunctionComponentOverload6.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload6.tsx index f2e799c1c8f..eb8f3f3d128 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload6.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload6.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/tsxStatelessFunctionComponents1.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponents1.tsx index b486a72ce15..36a11bcc513 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponents1.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponents1.tsx @@ -1,6 +1,7 @@ // @filename: file.tsx // @jsx: preserve // @noLib: true +// @skipLibCheck: true // @libFiles: react.d.ts,lib.d.ts function EmptyPropSFC() { 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/tsxStatelessFunctionComponentsWithTypeArguments2.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments2.tsx index e2a5f818428..aff36145e15 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments2.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments2.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/tsxStatelessFunctionComponentsWithTypeArguments3.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments3.tsx index 68285c450c0..b55f9a72b65 100644 --- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments3.tsx +++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentsWithTypeArguments3.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/tsxUnionTypeComponent1.tsx b/tests/cases/conformance/jsx/tsxUnionTypeComponent1.tsx index b9e50357185..09635bbaa16 100644 --- a/tests/cases/conformance/jsx/tsxUnionTypeComponent1.tsx +++ b/tests/cases/conformance/jsx/tsxUnionTypeComponent1.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/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts b/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts index 5da3805d01a..433c24ad2fa 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts +++ b/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts @@ -1,4 +1,5 @@ // @target: esnext +// @skipLibCheck: true // @lib: esnext // @noEmit: true // @filename: methodIsOk.ts 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') diff --git a/tests/cases/fourslash/codeFixUndeclaredAcrossFiles1.ts b/tests/cases/fourslash/codeFixUndeclaredAcrossFiles1.ts index 435b78ba3fa..a946b60f173 100644 --- a/tests/cases/fourslash/codeFixUndeclaredAcrossFiles1.ts +++ b/tests/cases/fourslash/codeFixUndeclaredAcrossFiles1.ts @@ -23,7 +23,7 @@ verify.getAndApplyCodeFix(/*errorCode*/undefined, 0); verify.getAndApplyCodeFix(/*errorCode*/undefined, 0); verify.rangeIs(` - y: { [x: string]: any; }; + y: {}; m1(): any { throw new Error("Method not implemented."); } diff --git a/tests/cases/fourslash/completionsJsPropertyAssignment.ts b/tests/cases/fourslash/completionsJsPropertyAssignment.ts new file mode 100644 index 00000000000..c7e8a9ad268 --- /dev/null +++ b/tests/cases/fourslash/completionsJsPropertyAssignment.ts @@ -0,0 +1,10 @@ +/// + +// @allowJs: true + +// @Filename: /a.js +/////** @type {{ p: "x" | "y" }} */ +////const x = { p: "x" }; +////x.p = "/**/"; + +verify.completionsAt("", ["x", "y"]); diff --git a/tests/cases/fourslash/getOccurrencesAbstract03.ts b/tests/cases/fourslash/getOccurrencesAbstract03.ts new file mode 100644 index 00000000000..29bdb3c2257 --- /dev/null +++ b/tests/cases/fourslash/getOccurrencesAbstract03.ts @@ -0,0 +1,21 @@ +/// + +// Tests that we don't crash when encountering an abstract class in these scopes: + +////function f() { +//// [|abstract|] class A { +//// [|abstract|] m(): void; +//// } +//// abstract class B {} +////} +////switch (0) { +//// case 0: +//// [|abstract|] class A { [|abstract|] m(): void; } +//// default: +//// [|abstract|] class B { [|abstract|] m(): void; } +////} + +const [r0, r1, r2, r3, r4, r5] = test.ranges(); +verify.rangesAreDocumentHighlights([r0, r1]); +verify.rangesAreDocumentHighlights([r2, r3]); +verify.rangesAreDocumentHighlights([r4, r5]); diff --git a/tests/cases/fourslash/getOutliningSpans.ts b/tests/cases/fourslash/getOutliningSpans.ts index 93665889eb4..4e2a58c9acb 100644 --- a/tests/cases/fourslash/getOutliningSpans.ts +++ b/tests/cases/fourslash/getOutliningSpans.ts @@ -79,32 +79,19 @@ //// }|] ////}|] //////outline with deep nesting -////module m1[|{ -//// module m2[| { -//// module m3[| { -//// module m4[| { -//// module m5[| { -//// module m6[| { -//// module m7[| { -//// module m8[| { -//// module m9[| { -//// module m10[| { -//// module m11 { -//// module m12 { -//// export interface IFoo { -//// } -//// } -//// } -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -////}|] +////var nest =[| [[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[ +//// [|[ +//// [ +//// [ +//// [ +//// [ +//// 1,2,3 +//// ] +//// ] +//// ] +//// ] +//// ]|] +////]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]; //// //////outline after a deeply nested node ////class AfterNestedNodes[| { diff --git a/tests/cases/fourslash/shims-pp/getOutliningSpans.ts b/tests/cases/fourslash/shims-pp/getOutliningSpans.ts index 93665889eb4..4e2a58c9acb 100644 --- a/tests/cases/fourslash/shims-pp/getOutliningSpans.ts +++ b/tests/cases/fourslash/shims-pp/getOutliningSpans.ts @@ -79,32 +79,19 @@ //// }|] ////}|] //////outline with deep nesting -////module m1[|{ -//// module m2[| { -//// module m3[| { -//// module m4[| { -//// module m5[| { -//// module m6[| { -//// module m7[| { -//// module m8[| { -//// module m9[| { -//// module m10[| { -//// module m11 { -//// module m12 { -//// export interface IFoo { -//// } -//// } -//// } -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -////}|] +////var nest =[| [[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[ +//// [|[ +//// [ +//// [ +//// [ +//// [ +//// 1,2,3 +//// ] +//// ] +//// ] +//// ] +//// ]|] +////]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]; //// //////outline after a deeply nested node ////class AfterNestedNodes[| { diff --git a/tests/cases/fourslash/shims/getOutliningSpans.ts b/tests/cases/fourslash/shims/getOutliningSpans.ts index 93665889eb4..4e2a58c9acb 100644 --- a/tests/cases/fourslash/shims/getOutliningSpans.ts +++ b/tests/cases/fourslash/shims/getOutliningSpans.ts @@ -79,32 +79,19 @@ //// }|] ////}|] //////outline with deep nesting -////module m1[|{ -//// module m2[| { -//// module m3[| { -//// module m4[| { -//// module m5[| { -//// module m6[| { -//// module m7[| { -//// module m8[| { -//// module m9[| { -//// module m10[| { -//// module m11 { -//// module m12 { -//// export interface IFoo { -//// } -//// } -//// } -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -//// }|] -////}|] +////var nest =[| [[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[[|[ +//// [|[ +//// [ +//// [ +//// [ +//// [ +//// 1,2,3 +//// ] +//// ] +//// ] +//// ] +//// ]|] +////]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]]|]; //// //////outline after a deeply nested node ////class AfterNestedNodes[| {